java aio 网络编程 服务端

    今天测试了一下AsynchronousServerSocketChannel进行网络编程，发现这个效率确实高。讲一下测试场景，AsynchronousServerSocketChannel监听连接，获取到连接以后，提交给线程池去执行任务。一开始有些地方比较迷惑，比如启动一个5个线程的连接池，当我有10个连接进来，按照每一个连接都会封装成任务的做法，岂不是有五个一开始会等待，直到之前的五个中有任务执行完了，剩余的五个任务才会陆续执行，这样的话，为什么人们都说它效率高呢？

    反正我一开始是有这个想法，于是我写了个测试，验证我的想法，发现并不是我想的那样，先看看代码，然后再详细说明一下。

 

package com.pzn.aio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class AioServer {
	
	public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
		//
		ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(5);
		
		//
		AsynchronousServerSocketChannel boss = AsynchronousServerSocketChannel.open();
		boss.bind(new InetSocketAddress("127.0.0.1", 9000));
		
		while (true) {
			
			System.out.println("active thread... " + pool.getActiveCount());
			
			AsynchronousSocketChannel worker = boss.accept().get();
			System.out.println("accepted a new connect.");
			pool.submit(new Task(worker));
		}
		
	}
	
}

   

package com.pzn.aio;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.TimeUnit;

public class Task implements Runnable {
	
	private final AsynchronousSocketChannel worker;
	
	public Task(AsynchronousSocketChannel worker) {
		this.worker = worker;
	}
	
	public void run() {
		try {
			worker.write(ByteBuffer.wrap("i am server.".getBytes("utf-8")), null, new CompletionHandler<Integer, Object>() {
				public void completed(Integer result, Object attachment) {
					try {
						TimeUnit.SECONDS.sleep(5);
						System.out.println("write completed.");
						worker.close();
					} catch (InterruptedException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
				public void failed(Throwable exc, Object attachment) {
					System.out.println("write failed.");
				}
			});
			System.out.println(Thread.currentThread() + " execute Asynchronous task.");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	}

}

    Task这个任务中，调用AsynchronousSocketChannel的write方法使用异步的方式，最后一个参数是回调，当server写数据完成后，会执行回调中的方法，我在回调方法completed中睡眠5秒时为了观察效果，看看线程池是否可以超过5个任务同时连接。

 

    结果表明，是可以的。实际上这个Task的run方法会立即执行完，根本不会去管回调中的睡眠时间，这样就相当于线程池会马上有空闲线程来处理新的连接，当然还是有一点的延迟，但不至于延迟等待5秒。特别要注意的是：执行回掉的方法，这个就不是我们所能干预的了，依赖操作系统的机制来进入回调，回调方法的执行已经和线程池没有关系了，因为所有提交的Task的run方法都已经执行结束了。