nio与io的比较

nio是new io的简称，从jdk1.4就被引入了。现在的jdk已经到了1.6了，可以说不是什么新东西了。但其中的一些思想值得我来研究。这两天，我研究了下其中的套接字部分，有一些心得，在此分享。
首先先分析下：为什么要nio套接字？
nio的主要作用就是用来解决速度差异的。举个例子：计算机处理的速度，和用户按键盘的速度。这两者的速度相差悬殊。如果按照经典的方法：一个用户设定一个线程，专门等待用户的输入，无形中就造成了严重的资源浪费：每一个线程都需要珍贵的cpu时间片，由于速度差异造成了在这个交互线程中的cpu都用来等待。
nio套接字是怎么做到的？
其实，其中的思想很简单：轮询。一个线程轮询多个input；传统的方式是：有n个客户端就要有n个服务线程+一个监听线程，现在采取这种凡是，可以仅仅使用1个线程来代替n个服务线程以此来解决。
具体应用例子：
在ftp的控制连接中，因为只有少量的字符命令进行传输，所以可以考虑利用这种轮询的方式实现，以节省资源。
具体见例子。

package com.cxz.io;   
  
import java.io.BufferedReader;   
import java.io.IOException;   
import java.io.InputStreamReader;   
import java.net.ServerSocket;   
import java.net.Socket;   
import java.util.HashMap;   
import java.util.Map;   
import java.util.Collections;   
  
public class IoEchoServer implements Runnable {   
  
    // ThreadLocal<Socket> localSocket = new ThreadLocal<Socket>();   
    Map<String, Socket> socketMap = Collections   
            .synchronizedMap(new HashMap<String, Socket>());   
  
    int threadCounter = 0;   
  
    synchronized private int getCounter() {   
        return threadCounter++;   
    }   
  
    public IoEchoServer() throws IOException {   
        ServerSocket server = new ServerSocket(1984);   
        while (true) {   
            Socket socket = server.accept();   
            // happened in the main thread.   
            // localSocket.set(socket);   
            String threadName = "---Thread" + getCounter() + "---";   
            socketMap.put(threadName, socket);   
            this.start(threadName);   
        }   
    }   
  
    /**  
     * @param args  
     * @throws IOException  
     */  
    public static void main(String[] args) throws IOException {   
        new IoEchoServer();   
    }   
  
    public void run() {   
        try {   
            Socket socket = socketMap.get(Thread.currentThread().getName());   
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));   
            //PrintWriter out = new PrintWriter(socket.getOutputStream());   
            String buffer = null;   
            while(!"END".equals(buffer)){   
                buffer = in.readLine();   
                System.out.println(buffer);   
            }   
            in.close();   
            socket.close();   
        } catch (IOException e) {   
            e.printStackTrace();   
        }   
    }   
  
    public void start(String threadName) {   
        new Thread(this, threadName).start();   
    }   
  
}  

下面这个例子采取了nio方式实现，虽然还是有阻塞部分，但是与上一个相比，效率已经大幅提高。仅仅阻塞到一个监听线程中。

package com.cxz.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Iterator;
import java.util.Set;

public class NioEchoServer {

	private static Selector roller = null;

	private static final int port = 8080;

	private static NioEchoServer instance = null;

	private ThreadLocal<StringBuffer> stringLocal = new ThreadLocal<StringBuffer>();

	private NioEchoServer() throws IOException {
		ServerSocketChannel serverChannel = ServerSocketChannel.open();
		serverChannel.socket().bind(new InetSocketAddress(port));
		serverChannel.configureBlocking(false);
		serverChannel.register(roller, SelectionKey.OP_ACCEPT);
	}

	public synchronized static NioEchoServer getInstance() throws IOException {
		if (instance == null) {
			roller = Selector.open();
			instance = new NioEchoServer();
		}
		return instance;
	}

	public void start() throws IOException {
		int keyAdded = 0;
		while ((keyAdded = roller.select()) > 0) {
			Set<SelectionKey> keySets = roller.selectedKeys();
			Iterator iter = keySets.iterator();
			while (iter.hasNext()) {
				SelectionKey key = (SelectionKey) iter.next();
				iter.remove();
				actionHandler(key);
			}
		}
	}

	public void actionHandler(SelectionKey key) throws IOException {
		if (key.isAcceptable()) {
			ServerSocketChannel serverChannel = (ServerSocketChannel) key
					.channel();
			SocketChannel socketChannel = serverChannel.accept();
			socketChannel.configureBlocking(false);
			socketChannel.register(roller, SelectionKey.OP_READ);
		} else if (key.isReadable()) {
			ByteBuffer buffer = ByteBuffer.allocate(16);
			SocketChannel socketChannel = (SocketChannel) key.channel();
			socketChannel.read(buffer);
			buffer.flip();
			String temp = decode(buffer);
			StringBuffer strBuffer = stringLocal.get();
			if (strBuffer == null) {
				strBuffer = new StringBuffer();
			}

			strBuffer.append(temp);

			if (temp.equals("\r\n")) {
				System.out.println(strBuffer.toString());
				strBuffer = null;
			}
			stringLocal.set(strBuffer);
		}
	}

	public String decode(ByteBuffer buffer) {
		Charset charset = null;
		CharsetDecoder decoder = null;
		CharBuffer charBuffer = null;
		try {
			charset = Charset.forName("UTF-8");
			decoder = charset.newDecoder();
			charBuffer = decoder.decode(buffer);
			return charBuffer.toString();
		} catch (Exception ex) {
			ex.printStackTrace();
			return "";
		}
	}

	public static void main(String[] args) {
		try {
			NioEchoServer.getInstance().start();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

评论

7 楼 flychao88 2015-03-06  

nothingismao 写道

623deyingxiong 写道

wwj85523 写道

看完后我迷糊了,
IO一样可以一个线程管理多个socket啊
貌似这不是NIO和IO的差别

是啊，一个线程负责监听，有请求过来就拉过来一个工作线程处理请求。这跟NIO的模式有区别吗？
另外，NIO有一个while循环不断地轮询各个通道，这难道就是非阻塞？

第1.NIO中Selector负责监听,对于过来的请求可以不用另外起启动线程去除了,而IO中则必须为每一个连接去创建线程处理.这个有很大区别.而且在IO中创建的线程很多时候是处于阻塞状态,这时候CPU会进行时间片切换不同的线程造成资源的损耗.
第2.个人觉得NIO中while判断是否有事件是通过事件请求的机制实现的.如果底层还是给每个连接创建一个线程的话NIO没任何意义.所以实际NIO中用于处理连接的线程可以只有一个.

楼主说的每个IO必须要起一个线程处理，这是采用线程池的方式，也可以不用另外起线程。
我认为楼主没有说清楚NIO和IO的本质区别，从字面上的意思，似乎两者并没有太大的区别，从我个人感觉NIO和IO有本质区别，是因为NIO是非阻塞，这个非阻塞怎么理解，就是当NIO的处理逻辑出现阻塞的时候，NIO会继续接收新的请求来处理，待上一次阻塞的逻辑改变了状态后，NIO再继续回来执行，如果是IO的话，不管起多少个线程，遇到阻塞则会一直等待下去，不会动态的切换。

6 楼 李冰冰 2014-10-13  

如果NIO单个线程处理业务逻辑，那么如果这个业务逻辑非常耗时，此时其余的线程其实是都需要等待这个主逻辑处理结束之后，才会重新调用select()函数，进行取数据处理，如果这样，为何不像IO那样一个请求开辟一个线程来进行业务处理，而不会因为业务处理负责，导致其他的请求数据造成延迟，请楼主给予解释，谢谢。

5 楼 wj_126mail 2014-03-29  

IO是一个连接就创建一个线程来处理；

NIO是一个线程在处理所有的SCOKET。

4 楼 nothingismao 2013-11-27  

623deyingxiong 写道

wwj85523 写道

看完后我迷糊了,
IO一样可以一个线程管理多个socket啊
貌似这不是NIO和IO的差别

是啊，一个线程负责监听，有请求过来就拉过来一个工作线程处理请求。这跟NIO的模式有区别吗？
另外，NIO有一个while循环不断地轮询各个通道，这难道就是非阻塞？

第1.NIO中Selector负责监听,对于过来的请求可以不用另外起启动线程去除了,而IO中则必须为每一个连接去创建线程处理.这个有很大区别.而且在IO中创建的线程很多时候是处于阻塞状态,这时候CPU会进行时间片切换不同的线程造成资源的损耗.
第2.个人觉得NIO中while判断是否有事件是通过事件请求的机制实现的.如果底层还是给每个连接创建一个线程的话NIO没任何意义.所以实际NIO中用于处理连接的线程可以只有一个.

3 楼 623deyingxiong 2013-01-12  

wwj85523 写道

看完后我迷糊了,
IO一样可以一个线程管理多个socket啊
貌似这不是NIO和IO的差别

是啊，一个线程负责监听，有请求过来就拉过来一个工作线程处理请求。这跟NIO的模式有区别吗？
另外，NIO有一个while循环不断地轮询各个通道，这难道就是非阻塞？

2 楼 wwj85523 2011-04-13  

看完后我迷糊了,
IO一样可以一个线程管理多个socket啊
貌似这不是NIO和IO的差别

1 楼 wj_126mail 2010-07-21  

NIO比IO可以提高效率，但为什么可以提高效率，以及是怎样提高效率的，不一定都明白，LZ讲的明白的很，学习过后，表示感谢！