一、NIO的出现
NIO是JDK1.4里面才出现的东东,他给大家带来的最大好处是异步socket。其它file,pipe暂时就不多谈了。
在JDK1.4出现之前,如果你需要编写一个Java服务器,为了实现异步操作,你必须为每个连接请求生成一个Java线程,当连接请求很多时,线程的调度,上下文切换,所付出的代价是非常昂贵,而且由于Java是跨平台的,各个平台对线程的支持并不相同,性能也不相同,因此传统的Java服务器编程架构是低效的且代价贵,dl大侠写了个util.concurrent包后,总算是减轻了线程调度给java程序员带来的痛苦,但是相比之与C、C++写出来的服务器,java服务器在性能要求很高的情况下,基本上没有什么竞争力,甚至是入围的权利的都没有。
二、异步socket的实现
NIO出现后,好像让java的程序员有了杨眉吐气的机会,怎么个吐气法,当时大家是个什么感受,俺是不知道,因为当时俺不搞java,对java的认识有限。
NIO 是一个基于事件的IO架构,最基本的思想就是:有事件我通知你,你再去做你的事情,没事件时你大可以节约大把时间去做其它任何事情。而且NIO的主线程 only one,不像传统的模型,需要N个线程去,也减轻了JVM的工作量,使得JVM处理任务时显得更加高效。
刚开始接触 NIO时,被N层的Channel架构、网上铺天盖地的好评给镇住了,想想也应当是个很成熟的产品了,网上资料这么多,抄一抄Jetty、Tomcat以及其它一些牛B的源代码,基本上就能搞定了,此时没有想到大家受同步的影响这么深,也没有想到连最基本的异步概念都没有搞清楚就去写代码,搞出一堆的问题来(这是后话,后面再说)。
现在研究了NIO以后,发现NIO实际上在Java中做的工作是很简单,就是将事件进行收集和分发。
NIO方案
目前,单独线程管理单条Socket链路,之所以耗费资源的根本原因在于:每个线程以阻塞的方式工作,很可能在Socket链路没有数据传输的时候处于Idle状态,比较浪费;浪费的严重程度取决于处于Idle状态的时间长度。
举一个例子,非常不切实际,但希望能够说明问题。
银行柜台,十位工作人员同时工作,第一位负责接待帐号尾号为0的客户、第二位负责接待帐号尾号为1的客户……依此类推。这样,如果一整天都没有一个帐号尾号为0的客户上门,那么第一位工作人员就打盹儿一整天。
显然效率较低。
就这个例子,更好的模式应该是:一位工作人员负责接待所有客户,在没有客户上门的时候可以打盹儿,有客户上门时,类似Seven-Eleven门口的“欢迎光临”口号把打盹儿中的工作人员惊醒,开始接待工作。或者,客户较多,工作人员非但没有机会打盹儿,客户还总需要排队,就可以稍微多设置几位地位平等工作人员,每次客户上门,随意一位恰好闲着的就负责接待。类似于我们现实世界的情形。
Java NIO,就提供了机制采用后一种模式进行工作。
Java NIO
概述
NIO是Java1.4相对于过去版本的一个较大的功能亮点,N表示New,相关API部署在java.nio.*包中。NIO更多地利用了现代操作系统所提供的底层I/O机制,为我们提供了一种更加高效的I/O解决方案。
Java1.4之前,Java的I/O相关的内容,均由java.io.*包解决,为了描述方便,暂称为“旧IO”。旧IO最重要的概念是流(InputStream和OutputStream)。旧IO以流的方式处理数据。旧IO以阻塞的方式操控流数据。
与本方案相关的,NIO最重要的概念是Buffer、Channel、Selector。NIO以块的方式处理数据。NIO可以按照非阻塞的方式操控数据。
下面简要说明一下NIO的工作模式。(注:仅介绍与本方案相关的NIO内容。)
概念
1. Buffer:在NIO的世界中,所有数据都在Buffer中,从Buffer中读、写入Buffer。每中基本数据类型都有一个对应的Buffer类,其中ByteBuffer最为常用,也比较特殊——与Channel类联系最为紧密。
Buffer有三个状态变量:position、limit、capacity。Buffer可理解为比较高级的数据,这几个状态变量描述了数组中的数据装载情况,从变量名即可大约知道他们各自是什么意思。详细信息可参考本文末尾罗列的相关参考文献。
2. Channel:类似于旧IO的Stream,ServerSocket、Socket都有对应的Channel类,即ServerSocketChannel、SocketChannel,他们之间是双向关联的,即可以互相取得对方的句柄。与Stream不同的是,Channel是双向的。我们需要着重注意的是,SelectableChannel类,顾名思义,该类及其子类,表示“可以被选择”,说得更清楚一些,这样的Channel可以注册到某个Selector对象上,Selector对象可以在Channel关注的某些事件到来的时候,以某种方式给予通知。与著名的Observer模式在思路上惺惺相惜。事实上,我们所关心的ServerSocketChannel、SocketChannel都是SelectableChannel的子类。
3. Selector:可理解为Channel们的调度器,多个Channel可以注册到一个Selector对象,如前所述,Selector在Channel关注的事件发生的时候给予通知。比如,ServerSocketChannel在注册到Selector的时候表示,我关心accept操作,即关心哪些客户端试图与我建链;再比如,SocketChannel就关心read操作,看看什么时候会从Socket上读到数据。Selector提供的select方法是我们最为关注的,该方法是同步的,返回此时Selector收到的所有事件,返回形式是包含多个SelectionKey的Set。
[color=red]4. SelectionKey:包裹Selector和Channel关联关系的类。从SelectionKey中可以得到如下信息:Channel、Selector、操作类型(accept、read、write)等。
如何利用NIO解决我们的问题
1. 我们的基本设备:ServerSocketChannel*1、Selector*1、SocketChannel*N、SelectionKey*N、工作线程Worker*1(也可以是由少量线程组成的线程池,即Worker*M)。
2. 开启ServerSocketChannel,并打开某端口,等待客户端接入。
3. 将ServerSocketChannel注册到Selector上,表示自己关心accept操作,即关心哪些客户端来请求建链。
4. Worker启动,while-true调用Selector的select方法。
5. 有客户端请求上来的时候,select方法会返回相关的SelectionKey对象,从中取得ServerSocketChannel对象,并调用其accept方法获得SocketChannel。
6. 把获得的SocketChannel注册到Selector上,同时保存起来,并表示自己关心read操作,即关心何时、从该Socket上读到什么数据。
7. (此时,while-true调用Selector的select方法仍旧在马不停蹄地运行着)当有某个Socket有数据上来的时候,select方法会返回相关的SelectionKey对象,从中取得SocketChannel对象,调用read方法读出数据。[/color]
可以看出,利用NIO,一个工作线程可以完成所有Socket的数据读取,从根本上解决了上面的问题。当然,如果有需要,也可以设置线程池,或可进一步提高性能。
首先先分析下:为什么要nio套接字?
nio的主要作用就是用来解决速度差异的。举个例子:计算机处理的速度,和用户按键盘的速度。这两者的速度相差悬殊。如果按照经典的方法:一个用户设定一个线程,专门等待用户的输入,无形中就造成了严重的资源浪费:每一个线程都需要珍贵的cpu时间片,由于速度差异造成了在这个交互线程中的cpu 都用来等待。
nio套接字是怎么做到的?
其实,[color=red]其中的思想很简单:轮询。一个线程轮询多个input;传统的方式是:有n个客户端就要有n个服务线程+一个监听线程,现在采取这种凡是,可以仅仅使用1个线程来代替n个服务线程以此来解决。 [/color]
下面这个例子采取了nio方式实现,虽然还是有阻塞部分,但是与上一个相比,效率已经大幅提高。仅仅阻塞到一个监听线程中。
NIO是JDK1.4里面才出现的东东,他给大家带来的最大好处是异步socket。其它file,pipe暂时就不多谈了。
在JDK1.4出现之前,如果你需要编写一个Java服务器,为了实现异步操作,你必须为每个连接请求生成一个Java线程,当连接请求很多时,线程的调度,上下文切换,所付出的代价是非常昂贵,而且由于Java是跨平台的,各个平台对线程的支持并不相同,性能也不相同,因此传统的Java服务器编程架构是低效的且代价贵,dl大侠写了个util.concurrent包后,总算是减轻了线程调度给java程序员带来的痛苦,但是相比之与C、C++写出来的服务器,java服务器在性能要求很高的情况下,基本上没有什么竞争力,甚至是入围的权利的都没有。
二、异步socket的实现
NIO出现后,好像让java的程序员有了杨眉吐气的机会,怎么个吐气法,当时大家是个什么感受,俺是不知道,因为当时俺不搞java,对java的认识有限。
NIO 是一个基于事件的IO架构,最基本的思想就是:有事件我通知你,你再去做你的事情,没事件时你大可以节约大把时间去做其它任何事情。而且NIO的主线程 only one,不像传统的模型,需要N个线程去,也减轻了JVM的工作量,使得JVM处理任务时显得更加高效。
刚开始接触 NIO时,被N层的Channel架构、网上铺天盖地的好评给镇住了,想想也应当是个很成熟的产品了,网上资料这么多,抄一抄Jetty、Tomcat以及其它一些牛B的源代码,基本上就能搞定了,此时没有想到大家受同步的影响这么深,也没有想到连最基本的异步概念都没有搞清楚就去写代码,搞出一堆的问题来(这是后话,后面再说)。
现在研究了NIO以后,发现NIO实际上在Java中做的工作是很简单,就是将事件进行收集和分发。
NIO方案
目前,单独线程管理单条Socket链路,之所以耗费资源的根本原因在于:每个线程以阻塞的方式工作,很可能在Socket链路没有数据传输的时候处于Idle状态,比较浪费;浪费的严重程度取决于处于Idle状态的时间长度。
举一个例子,非常不切实际,但希望能够说明问题。
银行柜台,十位工作人员同时工作,第一位负责接待帐号尾号为0的客户、第二位负责接待帐号尾号为1的客户……依此类推。这样,如果一整天都没有一个帐号尾号为0的客户上门,那么第一位工作人员就打盹儿一整天。
显然效率较低。
就这个例子,更好的模式应该是:一位工作人员负责接待所有客户,在没有客户上门的时候可以打盹儿,有客户上门时,类似Seven-Eleven门口的“欢迎光临”口号把打盹儿中的工作人员惊醒,开始接待工作。或者,客户较多,工作人员非但没有机会打盹儿,客户还总需要排队,就可以稍微多设置几位地位平等工作人员,每次客户上门,随意一位恰好闲着的就负责接待。类似于我们现实世界的情形。
Java NIO,就提供了机制采用后一种模式进行工作。
Java NIO
概述
NIO是Java1.4相对于过去版本的一个较大的功能亮点,N表示New,相关API部署在java.nio.*包中。NIO更多地利用了现代操作系统所提供的底层I/O机制,为我们提供了一种更加高效的I/O解决方案。
Java1.4之前,Java的I/O相关的内容,均由java.io.*包解决,为了描述方便,暂称为“旧IO”。旧IO最重要的概念是流(InputStream和OutputStream)。旧IO以流的方式处理数据。旧IO以阻塞的方式操控流数据。
与本方案相关的,NIO最重要的概念是Buffer、Channel、Selector。NIO以块的方式处理数据。NIO可以按照非阻塞的方式操控数据。
下面简要说明一下NIO的工作模式。(注:仅介绍与本方案相关的NIO内容。)
概念
1. Buffer:在NIO的世界中,所有数据都在Buffer中,从Buffer中读、写入Buffer。每中基本数据类型都有一个对应的Buffer类,其中ByteBuffer最为常用,也比较特殊——与Channel类联系最为紧密。
Buffer有三个状态变量:position、limit、capacity。Buffer可理解为比较高级的数据,这几个状态变量描述了数组中的数据装载情况,从变量名即可大约知道他们各自是什么意思。详细信息可参考本文末尾罗列的相关参考文献。
2. Channel:类似于旧IO的Stream,ServerSocket、Socket都有对应的Channel类,即ServerSocketChannel、SocketChannel,他们之间是双向关联的,即可以互相取得对方的句柄。与Stream不同的是,Channel是双向的。我们需要着重注意的是,SelectableChannel类,顾名思义,该类及其子类,表示“可以被选择”,说得更清楚一些,这样的Channel可以注册到某个Selector对象上,Selector对象可以在Channel关注的某些事件到来的时候,以某种方式给予通知。与著名的Observer模式在思路上惺惺相惜。事实上,我们所关心的ServerSocketChannel、SocketChannel都是SelectableChannel的子类。
3. Selector:可理解为Channel们的调度器,多个Channel可以注册到一个Selector对象,如前所述,Selector在Channel关注的事件发生的时候给予通知。比如,ServerSocketChannel在注册到Selector的时候表示,我关心accept操作,即关心哪些客户端试图与我建链;再比如,SocketChannel就关心read操作,看看什么时候会从Socket上读到数据。Selector提供的select方法是我们最为关注的,该方法是同步的,返回此时Selector收到的所有事件,返回形式是包含多个SelectionKey的Set。
[color=red]4. SelectionKey:包裹Selector和Channel关联关系的类。从SelectionKey中可以得到如下信息:Channel、Selector、操作类型(accept、read、write)等。
如何利用NIO解决我们的问题
1. 我们的基本设备:ServerSocketChannel*1、Selector*1、SocketChannel*N、SelectionKey*N、工作线程Worker*1(也可以是由少量线程组成的线程池,即Worker*M)。
2. 开启ServerSocketChannel,并打开某端口,等待客户端接入。
3. 将ServerSocketChannel注册到Selector上,表示自己关心accept操作,即关心哪些客户端来请求建链。
4. Worker启动,while-true调用Selector的select方法。
5. 有客户端请求上来的时候,select方法会返回相关的SelectionKey对象,从中取得ServerSocketChannel对象,并调用其accept方法获得SocketChannel。
6. 把获得的SocketChannel注册到Selector上,同时保存起来,并表示自己关心read操作,即关心何时、从该Socket上读到什么数据。
7. (此时,while-true调用Selector的select方法仍旧在马不停蹄地运行着)当有某个Socket有数据上来的时候,select方法会返回相关的SelectionKey对象,从中取得SocketChannel对象,调用read方法读出数据。[/color]
可以看出,利用NIO,一个工作线程可以完成所有Socket的数据读取,从根本上解决了上面的问题。当然,如果有需要,也可以设置线程池,或可进一步提高性能。
首先先分析下:为什么要nio套接字?
nio的主要作用就是用来解决速度差异的。举个例子:计算机处理的速度,和用户按键盘的速度。这两者的速度相差悬殊。如果按照经典的方法:一个用户设定一个线程,专门等待用户的输入,无形中就造成了严重的资源浪费:每一个线程都需要珍贵的cpu时间片,由于速度差异造成了在这个交互线程中的cpu 都用来等待。
nio套接字是怎么做到的?
其实,[color=red]其中的思想很简单:轮询。一个线程轮询多个input;传统的方式是:有n个客户端就要有n个服务线程+一个监听线程,现在采取这种凡是,可以仅仅使用1个线程来代替n个服务线程以此来解决。 [/color]
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();
}
}
}