1 public class ClientAio implements Runnable {
 2     private final static int count = 50000;
 3     private final static AsynchronousSocketChannel[] clients = new AsynchronousSocketChannel[count];
 4     private final static AtomicInteger ai = new AtomicInteger();
 5
 6     private String host;
 7     private int port;
 8     private AsynchronousSocketChannel client;
 9
10     public ClientAio(String host, int port) throws IOException {
11         this.client = AsynchronousSocketChannel.open();
12         this.host = host;
13         this.port = port;
14     }
15
16     public static void main(String[] args) throws Exception {
17         String addr = args.length > 0 ? args[0] : "192.168.56.122";
18         while (ai.get() < count) {
19             new ClientAio(addr, 8989).run();
20         }
21         System.in.read();
22     }
23
24     public void run() {
25         client.connect(new InetSocketAddress(host, port), null, new CompletionHandler<Void, Object>() {
26             public void completed(Void result, Object attachment) {
27                 int i = ai.getAndIncrement();
28                 if (i < count) {
29                     clients[i] = client;
30                 }
31                 final ByteBuffer byteBuffer = ByteBuffer.allocate(512);
32                 client.read(byteBuffer, null, new CompletionHandler<Integer, Object>() {
33                     public void completed(Integer result, Object attachment) {
34
35                         //System.out.println("client read data: " + new String(byteBuffer.array()));
36                     }
37
38                     public void failed(Throwable exc, Object attachment) {
39                         System.out.println("read faield");
40                     }
41                 });
42             }
43
44             public void failed(Throwable exc, Object attachment) {
45                 System.out.println("client connect field...");
46                 try {
47                     if(client.isOpen()){
48                      client.close();
49                     }
50                 } catch (IOException e) {
51                 }
52             }
53         });
54     }
55 }

 1 public class ServerAio implements Runnable {
 2     private final static AtomicInteger ai = new AtomicInteger();
 3     private int port = 8889;
 4     private int threadSize = 10;
 5     private AsynchronousChannelGroup asynchronousChannelGroup;
 6     private AsynchronousServerSocketChannel serverChannel;
 7
 8     public ServerAio(int port, int threadSize) {
 9         this.port = port;
10         this.threadSize = threadSize;
11     }
12
13     public static void main(String[] args) throws IOException {
14         new ServerAio(8989, Runtime.getRuntime().availableProcessors() * 10).run();
15         System.in.read();
16     }
17
18     public void run() {
19         try {
20             asynchronousChannelGroup = AsynchronousChannelGroup.withCachedThreadPool(Executors.newCachedThreadPool(), threadSize);
21             serverChannel = AsynchronousServerSocketChannel.open(asynchronousChannelGroup);
22             serverChannel.bind(new InetSocketAddress(port));
23             System.out.println("listening on port: " + port);
24             serverChannel.accept(this, new CompletionHandler<AsynchronousSocketChannel, ServerAio>() {
25
26                 public void completed(AsynchronousSocketChannel result, ServerAio attachment) {
27                     try {
28                         System.out.println(ai.getAndIncrement());
29                         ByteBuffer echoBuffer = ByteBuffer.allocateDirect(1024);
30                         result.read(echoBuffer, null, new CompletionHandler<Integer, Object>() {
31                             @Override
32                             public void completed(Integer result, Object attachment) {
33                             // System.out.println("received : " +
34                             // Charset.defaultCharset().decode(echoBuffer));
35                             }
36
37                             @Override
38                             public void failed(Throwable exc, Object attachment) {
39                             }
40                         });
41
42                         result.write(ByteBuffer.wrap("ok".getBytes()));
43                     } catch (Exception e) {
44                         e.printStackTrace();
45                     } finally {
46                         attachment.serverChannel.accept(attachment, this);// 监听新的请求，递归调用。
47                     }
48                 }
49
50                 public void failed(Throwable exc, ServerAio attachment) {
51                     System.out.println("received failed");
52                     exc.printStackTrace();
53                     attachment.serverChannel.accept(attachment, this);// 监听新的请求，递归调用。
54                 }
55             });
56
57         } catch (Exception e) {
58             e.printStackTrace();
59         }
60     }
61 }