Netty3学习笔记（一） --- 传统IO与NIO比较

	   	server.accept();     等待链接
       	inputStream.read(bytes);     等待输入

		File.read(fileDesc, buf, len);
		Socket.send(socket, buf, len);

		1. 上下文切换(context switch), 此处有4次用户态和内核态的切换
		2. Buffer内存开销, 一个是应用程序buffer, 另一个是系统读取buffer以及socket buffer

	1) 先将文件内容从磁盘中拷贝到操作系统buffer
	2) 再从操作系统buffer拷贝到程序应用buffer
	3) 从程序buffer拷贝到socket buffer
	4) 从socket buffer拷贝到协议引擎.

public class OioServer {
@SuppressWarnings("resource")
public static void main(String[] args) throws Exception {

	ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
	//创建socket服务,监听10101端口
	ServerSocket server=new ServerSocket(10101);
	System.out.println("服务器启动！");
	while(true){
		//获取一个套接字（阻塞）
		final Socket socket = server.accept();
		System.out.println("来个一个新客户端！");
		newCachedThreadPool.execute(new Runnable() {
			
			@Override
			public void run() {
				//业务处理
				handler(socket);
			}
		});
		
	}
}

/**
 * 读取数据
 * @param socket
 * @throws Exception
 */
public static void handler(Socket socket){
		try {
			byte[] bytes = new byte[1024];
			InputStream inputStream = socket.getInputStream();
			
			while(true){
				//读取数据（阻塞）
				int read = inputStream.read(bytes);
				if(read != -1){
					System.out.println(new String(bytes, 0, read));
				}else{
					break;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				System.out.println("socket关闭");
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
}}

	public void transferTo(long position, long count, WritableByteChannel target);

	sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

(1)客户端关闭的时候会抛出异常，死循环
    
    解决方案:
	int read = channel.read(buffer);
	if(read > 0){
		byte[] data = buffer.array();
		String msg = new String(data).trim();
		System.out.println("服务端收到信息：" + msg);
		
		//回写数据
		ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
		channel.write(outBuffer);// 将消息回送给客户端
	}else{
		System.out.println("客户端关闭");
		key.cancel();
	}

(2)selector.select();阻塞，那为什么说nio是非阻塞的IO？
   selector.select()
   selector.select(1000);不阻塞
   selector.wakeup();也可以唤醒selector
   selector.selectNow();也可以立马返回数据
   
(3)SelectionKey.OP_WRITE是代表什么意思
   OP_WRITE表示底层缓冲区是否有空间，是则响应返还true	

public class NIOServer {
// 通道管理器
private Selector selector;
/**
 * 获得一个ServerSocket通道，并对该通道做一些初始化的工作
 * 
 * @param port
 *            绑定的端口号
 * @throws IOException
 */
public void initServer(int port) throws IOException {
	// 获得一个ServerSocket通道
	ServerSocketChannel serverChannel = ServerSocketChannel.open();
	// 设置通道为非阻塞
	serverChannel.configureBlocking(false);
	// 将该通道对应的ServerSocket绑定到port端口
	serverChannel.socket().bind(new InetSocketAddress(port));
	// 获得一个通道管理器
	this.selector = Selector.open();
	// 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
	// 当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
	serverChannel.register(selector, SelectionKey.OP_ACCEPT);
}

/**
 * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
 * 
 * @throws IOException
 */
public void listen() throws IOException {
	System.out.println("服务端启动成功！");
	// 轮询访问selector
	while (true) {
		// 当注册的事件到达时，方法返回；否则,该方法会一直阻塞
		selector.select();
		// 获得selector中选中的项的迭代器，选中的项为注册的事件
		Iterator ite = this.selector.selectedKeys().iterator();
		while (ite.hasNext()) {
			SelectionKey key = (SelectionKey) ite.next();
			// 删除已选的key,以防重复处理
			ite.remove();

			handler(key);
		}
	}
}

/**
 * 处理请求
 * 
 * @param key
 * @throws IOException
 */
public void handler(SelectionKey key) throws IOException {
	
	// 客户端请求连接事件
	if (key.isAcceptable()) {
		handlerAccept(key);
		// 获得了可读的事件
	} else if (key.isReadable()) {
		handelerRead(key);
	}
}

/**
 * 处理连接请求
 * 
 * @param key
 * @throws IOException
 */
public void handlerAccept(SelectionKey key) throws IOException {
	ServerSocketChannel server = (ServerSocketChannel) key.channel();
	// 获得和客户端连接的通道
	SocketChannel channel = server.accept();
	// 设置成非阻塞
	channel.configureBlocking(false);

	// 在这里可以给客户端发送信息哦
	System.out.println("新的客户端连接");
	// 在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
	channel.register(this.selector, SelectionKey.OP_READ);
}

/**
 * 处理读的事件
 * 
 * @param key
 * @throws IOException
 */
public void handelerRead(SelectionKey key) throws IOException {
	// 服务器可读取消息:得到事件发生的Socket通道
	SocketChannel channel = (SocketChannel) key.channel();
	// 创建读取的缓冲区
	ByteBuffer buffer = ByteBuffer.allocate(1024);
	int read = channel.read(buffer);
	if(read > 0){
		byte[] data = buffer.array();
		String msg = new String(data).trim();
		System.out.println("服务端收到信息：" + msg);
		
		//回写数据
		ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
		channel.write(outBuffer);// 将消息回送给客户端
	}else{
		System.out.println("客户端关闭");
		key.cancel();
	}
}

/**
 * 启动服务端测试
 * 
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
	NIOServer server = new NIOServer();
	server.initServer(8000);
	server.listen();
}}