java NIO原理和应用

标签：java   tcpip   nio   

之前做的一个项目，先开始用的是BIO（即阻塞式IO），然后因为一些性能问题，然后用NIO（即非阻塞式IO）替换了BIO。

我们先说说BIO有什么缺点为什么要使用NIO：

以java中TCP为例来讲解：

我们知道，在客户端java调用connect方法会阻塞，调用read的时候也会阻塞也就是读不到就一直阻塞在那里，而服务器端呢，调用accept（）方法会阻塞，调用read方法也会阻塞这样的话，会对性能造成很大的影响。

接下来我们讲解NIO的原理，还是以TCP为例，现在很多框架中都在用NIO像是mina框架，以及java中RMI调用等等都会用到NIO，如果堆NIO原理不清楚的话，就很容易造成性能，上的问题：

1.NIO中主要的概念：

        第一个概念就是Channel，即通道，在BIO中是通过输入输出流来交互的，但是这些流是单向的，不能双向流通，那么在NIO中用Channel代替了流，作为通信，那么Channel是双向的，也就是数据流动的方式是双向的，也就服务器或者是客户端，谁想读取数据，就从channel中读取,谁想写入数据就向channel中写入数据。现在把流替换成管道就能实现NIO了吗，当然不可以，所以设计到了，第二个概念。

        第二个主要概念就是Selector，NIO中就是通过这个概念来解决了阻塞的问题，在讲这个概念的时候我们得先，知道NIO的一点工作方式，NIO之所以是非阻塞的是因为，NIO是事件驱动的，而不是BIO中，通过阻塞实现的，这么说有点不清楚，那么我们举例说明，先讲什么是事件驱动，例如你没话费了，而且手机坏了不能接收短信，同时你也不能上网，那么你必须跑去营业厅查看，是不是欠费了，而如果营业厅没开门，你就回家去干其他的事。而阻塞是什么呢，就是如果营业厅不开门，你一直等在营业厅门口，知道开门查完你你才回家去，当然在营业厅的时候你不能干任何事情。那么我的NIO就是需要你不断的去看营业厅是否开门了，就是多跑几趟。这时问题出现了，那如果你回家了，这时候营业厅门开了，但是你没去，那岂不是就错过了。而NIO对于这个问题的解决方法是这样的，如果你和营业厅的人很熟，那么可能有人会把要是放在一个容器中说，你要是想查话费就去这个容器中取钥匙吧，假设这个容器是个盒子，那么你如果错过了的话，你就可以去盒子中取钥匙然后开门查看。那么Selector其实就相当于这个容器，而事件就相当于是钥匙，每次如果说想查看没有数据需要读取，那么就遍历这个盒子，如果盒子中有代表读事件的钥匙，那么就去管道当中读取，因为在通信过程中有好多事件，像是读（read），写（write），连接（connect），接收连接（accept），那么就相当于有四种钥匙，看到不同的时间去执行，不同的操作。那么这个时候新的问题又来了，假如你的手机是移动的，而且放钥匙的盒子在一个公共的地方，也就是说，移动的人能够往这个盒子中放钥匙，联通的人也能往这个盒子中放钥匙，那么你假如拿钥匙的时候，拿了联通的钥匙，然后你还去开联通的门，这时候你是不是就进错房间了，房间就相当于是channel，selector是公共的，你拿到的别的连接的时间，那么你岂不是就进错channel了，另一中情况是你不知道，拿着该时间，往哪个通道里写数据或者是读数据，这时候第三个重要的概念，就出现了。

       第三个主要概念就是register注册，就是将selector注册给通道，也就是每一个通道一个selector，当然某些时候selector是可以被channel公用的，但是建议一个channel注册一个selector，这样的话在用你的channel的时候，就获取不到别的channel的事件了，也就是移动和联通每个都有一个盒子，你去不同地方拿钥匙，就会去到不同的房间。但是这样还是会有问题，你如果只是想去查手机话费，但是移动的盒子里放着两把，钥匙一把是移动营业厅的前门钥匙，一把是移动营业厅的后门钥匙，但是你指向从前门进，不想从后门进，也就是说，你对后门那把钥匙不感兴趣，我们人当然是不去拿他就好了，但是在程序中没这么智能，也就是在程序中，必须得看看这个钥匙是不是前门的，但是就是看这个动作在程序中也是耗时的，这时候为了解决这个问题，又出现第四个概念。

      第四个主要概念，也可以说是一种规范，不是强制的，就是设置selector中的时间类型，如果说selector中只对读感兴趣，那么其他类型的时间一旦到达的话，会被selector忽视也就是不会，把时间放入selector，也就是你告诉营业厅的人，不要把后门钥匙放在盒子里。

2.工作原理：

     经过以上的四个概念的阐述，我们队工作原理已经很清楚了，就是一个通信节点，先建立一个存储事件的selector，然后你还得注册感兴趣的时间，不然任何事件不会被放入，selector中，然后就是获取管道，因为管道总是需要通信双方有一方建立，建立通道后，然后给出你要连接的IP和端口，然后将IP和端口绑定在管道上，那么这个管道，会根据IP和port寻找你要通信的目标机，那么对方肯定会在一个已有的管道上，监听这个请求，如果监听到，那么就相当于管道，就对接好了，然后往管道上注册selector，管道双方的节点，都需要注册自己的selector，这样就可以通信了。一个节点，去查询selector，查询到事件后，然后响应时间，或是往通道里写数据，或是从通道里读数据，这样就可以通信了。基本原理是这样，但是在具体实施的时候还有一些细节问题需要搞懂，还有就是TCP连接的话，在客户端与服务器端是有点区别的，因为管道分为普通管道和服务器管道，但是两者其实没大区别，就是服务器管道主要是用来监听连接的，主要对accept事件，感兴趣，而普通管道主要是对读写事件感兴趣。为了帮助大家更好的理解，下面是我写个服务器代码和客户端代码，大家可以参考，基本就是一个客户端连接，那么在服务器端就建立一个线程进行处理。

服务器代码：

package com.test;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOServer {
	 //服务端用于监听的selector
     private Selector selector;
     
     public void initServer(int port) throws IOException{
    	 //获取一个ServerSocket通道
    	 ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
         //设置为非阻塞的
    	 serverSocketChannel.configureBlocking(false);
    	 //绑定端口
    	 serverSocketChannel.socket().bind(new InetSocketAddress(port));
    	 //获取一个监听器
    	 this.selector=Selector.open();
    	 //把channal于selector绑定
    	 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
     }
     static class TCPservice implements Runnable{
        
    	private Selector serviceSelector;
    	
    	private SocketChannel serviceChannel;
    	
    	public TCPservice(SocketChannel serviceChannel){
    		this.serviceChannel=serviceChannel;
    	}
    	private void init() throws IOException{
    		serviceSelector=Selector.open();
    		//注册读事件,绑定
    		serviceChannel.register(serviceSelector, SelectionKey.OP_READ);
    	}
    	 
		@Override
		public void run() {
			try {
				init();
				//轮询读事件
				int count=10;
				while(count>0){
					count--;
					//先写一条数据
					serviceChannel.write(ByteBuffer.wrap(new String("Hello client").getBytes()));
				    serviceSelector.select();
				    Iterator<SelectionKey> it=serviceSelector.selectedKeys().iterator();
				    while(it.hasNext()){
				    	SelectionKey key=it.next();
				    	it.remove();
				    	if(key.isReadable()){
				    		 ByteBuffer buffer = ByteBuffer.allocate(10);
				    		 serviceChannel.read(buffer);
				    		 String msg=new String(buffer.array());
				    		 System.out.println("服务器收到信息：  "+msg);
				    		 serviceChannel.write(ByteBuffer.wrap("ServerAck".getBytes()));
				    	}
				    }
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			
		}
    	 
     }
     //监听连接
     public void listen() throws IOException{
    	 System.out.println("服务端启动成功！");
    	 while(true){
    	    //轮询连接事件
    		selector.select(); 
    		//遍历连接事件
    		Iterator<SelectionKey> it=selector.selectedKeys().iterator();
    	    while(it.hasNext()){
    	    	SelectionKey key=it.next();
    	    	//以防重复处理
    	    	it.remove();
    	    	if(key.isAcceptable()){
    	    		//获取服务器通道
    	    		ServerSocketChannel serverSocketChannel=(ServerSocketChannel)key.channel();
    	    		//获取和客户端连接的通道
    	    		SocketChannel channel=serverSocketChannel.accept();
    	    		//设置成非阻塞
    	    		channel.configureBlocking(false);
    	    		//启动一个服务线程
    	    		System.out.println("开启一个服务线程");
    	    		Runnable service=new TCPservice(channel);
    	    	    new Thread(service).start();
    	    	}
    	    }
    	 }
     }
     
     public static void main(String[] args) throws IOException {
		NIOServer nioServer=new NIOServer();
		nioServer.initServer(9768);
		nioServer.listen();
	}
}

package com.test;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOClient {

	private Selector connectSelector;
	
	public void init(String ip,int port) throws IOException{
		//获取SocketChannel
		SocketChannel socketChannel=SocketChannel.open();
		//设置为非阻塞
		socketChannel.configureBlocking(false);
		//获取连接选择器
		connectSelector=Selector.open();
		//连接
		socketChannel.connect(new InetSocketAddress(ip, port));
		//注册连接事件
		socketChannel.register(connectSelector, SelectionKey.OP_CONNECT);
	}
	
	public void listen() throws IOException{
		while(true){
			connectSelector.select();
			Iterator<SelectionKey> it=connectSelector.selectedKeys().iterator();
			while(it.hasNext()){
				SelectionKey key=it.next();
				it.remove();
				if(key.isConnectable()){
					SocketChannel channal=(SocketChannel)key.channel();
					if(channal.isConnectionPending()){
						channal.finishConnect();
					}
					channal.configureBlocking(false);
					channal.write(ByteBuffer.wrap("Hello Server".getBytes()));
					channal.register(connectSelector, SelectionKey.OP_READ);
				}else if(key.isReadable()){
					// 服务器可读取消息:得到事件发生的Socket通道  
			        SocketChannel channel = (SocketChannel) key.channel();  
			        // 创建读取的缓冲区  
			        ByteBuffer buffer = ByteBuffer.allocate(10);  
			        channel.read(buffer);  
			        byte[] data = buffer.array();  
			        String msg = new String(data).trim();  
			        System.out.println("客户端收到信息：  "+msg);  
			        ByteBuffer outBuffer = ByteBuffer.wrap("client yes".getBytes());  
			        channel.write(outBuffer);// 将消息回送给客户端  
				}
			}
		}
	}
	public static void main(String[] args) throws IOException { 
        NIOClient nioClient=new NIOClient();
	    nioClient.init("127.0.0.1", 9768);
	    nioClient.listen();
	}

}

java NIO原理和应用

标签：java   tcpip   nio   

原文地址：http://blog.csdn.net/sxiaobei/article/details/47006647