Java NIO是在jdk1.4开始使用的,它既可以说成“新IO”,也可以说成非阻塞式I/O。下面是java NIO的工作原理:
-
由一个专门的线程来处理所有的IO事件,并负责分发。
-
事件驱动机制:事件到的时候触发,而不是同步的去监视事件。
-
线程通讯:线程之间通过wait,notify等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。
阅读过一些资料之后,下面贴出我理解的java NIO的工作原理图:
注:每个线程的处理流程大概都是读取数据,解码,计算处理,编码,发送响应。
Java NIO的服务端只需启动一个专门的线程来处理所有的IO事件,这种通信模型是怎么实现的呢?呵呵,我们一起来探究它的奥秘吧。java NIO采用了双向通道(channel)进行数据传输,而不是单向流(stream),在通道上可以注册我们感兴趣的事件。一共有以下四种事件:
事件名 | 对应值 |
服务端接收客户端连接事件 | SelectionKey.OP_ACCEPT(16) |
客户端连接服务端事件 | SelectionKey.OP_CONNECT(8) |
读事件 | SelectionKey.OP_READ(1) |
写事件 | SelectionKey.OP_WRITE(4) |
服务端和客户端各自维护一个管理通道的对象,我们称之为selector,该对象能检测一个或多个通道(channel)上的事件。我们以服务端为例,如果服务端的selector上注册了读事件,某时刻客户端给服务端送了一些数据,阻塞I/O这时会调用read()方法阻塞地读取数据,而NIO的服务端会在selector中添加一个读事件。服务端的处理线程会轮询地访问selector,如果访问selector时发现有感兴趣的事件到达,则处理这些事件,如果没有感兴趣的事件到达,则处理线程会一直阻塞直到感兴趣的事件到达为止。下面是我理解的java NIO的通信模型示意图:
为了更好地理解java NIO,下面贴出服务端和客户端的简单代码实现:
服务端:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
package
nio;
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.ServerSocketChannel;
import
java.nio.channels.SocketChannel;
import
java.util.Iterator;
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();
//客户请求连接事件
if
(key.isAcceptable()){
ServerSocketChannel server = (ServerSocketChannel)key.channel();
//获得和客户端连接的通道
SocketChannel channel = server.accept();
//设置成非阻塞
channel.configureBlocking(
false
);
//在这里可以给客户端发送信息哦
channel.write(ByteBuffer.wrap(
new
String(
"1234567890"
).getBytes()));
//在和客户端连接成功之后,为了可以接收到客户端的信息,需要给通道设置读权限
channel.register(
this
.selector, SelectionKey.OP_READ);
}
else
if
(key.isReadable()){
read(key);
}
}
}
}
/*
* 处理读取客户端发来的信息的事件
* @param key
* @throws IOException
*/
public
void
read(SelectionKey key )
throws
IOException{
//服务器可读取消息:得到事件发生的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(msg.getBytes());
channel.write(outBuffer);
//将消息回送给客户端
}
public
static
void
main(String[] args)
throws
IOException {
NIOServer server =
new
NIOServer();
server.initServer(
8080
);
server.listen();
}
}
|
客户端:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
package
nio;
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 selector;
/*
* 获得一个Socket通道,并对该通道做一些初始化的工作
* @param ip,连接的服务器的ip
* @param port,连接的服务器的端口号
* @throws IOException
*/
public
void
initClient(String ip,
int
port)
throws
IOException{
//获得一个Socket通道
SocketChannel channel = SocketChannel.open();
//设置通道为非阻塞
channel.configureBlocking(
false
);
//获得一个通道管理器
this
.selector = Selector.open();
/*客户端连接服务器,其实方法执行并没有实现连接,需要在listen()方法中
*调用channel.finishConnect()才能完成连接
*/
channel.connect(
new
InetSocketAddress(ip,port));
//将通道管理器和该通道绑定,并为该通道注册SelectionKey.OP_CONNECT事件
channel.register(
this
.selector, SelectionKey.OP_CONNECT);
}
/*
* 采用轮询的方式监听selector上是否有需要处理的事件,如果有,则进行处理。
* @throws IOException
*/
public
void
listen()
throws
IOException{
//轮询访问selector
while
(
true
){
/*
* 选择一组可以进行I/O操作的事件,放在selector中,客户端的该方法不会阻塞,
* 这里和服务端的方法不一样,查看api注释可以知道,当至少一个通道被选中时,
* selector的wakeup方法被调用,方法返回,而对于客户端来说,通道一直是被选中的
*/
selector.select();
//获得selector中选中的项的迭代器
Iterator ite =
this
.selector.selectedKeys().iterator();
while
(ite.hasNext()){
SelectionKey key = (SelectionKey) ite.next();
//删除已选的key,以防重复处理
ite.remove();
//连接事件发生
if
(key.isConnectable()){
SocketChannel channel = (SocketChannel) key.channel();
//如果正在连接,则完成连接
if
(channel.isConnectionPending()){
channel.finishConnect();
}
//设置成非阻塞
channel.configureBlocking(
false
);
//在这里可以给服务端发送信息哦
channel.write(ByteBuffer.wrap(
new
String(
"abcdefg"
).getBytes()));
//在和服务端连接成功之后,为了可以接收到服务端的信息,需要给通道设置读的权限
channel.register(
this
.selector, SelectionKey.OP_READ);
//获得了可读的事件
}
else
if
(key.isReadable()){
read(key);
}
}
}
}
public
void
read(SelectionKey key)
throws
IOException{
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(msg.getBytes());
channel.write(outBuffer);
}
public
static
void
main(String[] args)
throws
IOException{
NIOClient client =
new
NIOClient();
client.initClient(
"localhost"
,
8080
);
client.listen();
}
}
|
NIO 设计背后的基石:反应器模式,用于事件多路分离和分派的体系结构模式。
反应器(Reactor):用于事件多路分离和分派的体系结构模式
通 常的,对一个文件描述符指定的文件或设备, 有两种工作方式: 阻塞 与非阻塞 。所谓阻塞方式的意思是指, 当试图对该文件描述符进行读写时, 如果当时没有东西可读,或者暂时不可写, 程序就进入等待 状态, 直到有东西可读或者可写为止。而对于非阻塞状态, 如果没有东西可读, 或者不可写, 读写函数马上返回, 而不会等待 。
一种常用做法是:每建立一个Socket连接时,同时创建一个新线程对该Socket进行单独通 信(采用阻塞的方式通信)。这种方式具有很高的响应速度,并且控制起来也很简单,在连接数较少的时候非常有效,但是如果对每一个连接都产生一个线程的无疑 是对系统资源的一种浪费,如果连接数较多将会出现资源不足的情况。
另一种较高效的做法是:服务器端保存一个Socket连接列表,然后 对这个列表进行轮询,如果发现某个Socket端口上有数据可读时(读就绪),则调用该socket连接的相应读操作;如果发现某个 Socket端口上有数据可写时(写就绪),则调用该socket连接的相应写操作;如果某个端口的Socket连接已经中断,则调用相应的析构方法关闭 该端口。这样能充分利用服务器资源,效率得到了很大提高。
转自:http://javag.javaeye.com/blog/221641
传统的阻塞式IO,每个连接必须要开一个线程来处理,并且没处理完线程不能退出。
非 阻塞式IO,由于基于反应器模式,用于事件多路分离和分派的体系结构模式,所以可以利用线程池来处理。事件来了就处理,处理完了就把线程归还。而传统阻塞 方式不能使用线程池来处理,假设当前有10000个连接,非阻塞方式可能用1000个线程的线程池就搞定了,而传统阻塞方式就需要开10000个来处理。 如果连接数较多将会出现资源不足的情况。非阻塞的核心优势就在这里。
为什么会这样,下面就对他们做进一步细致具体的分析:
首 先,我们来分析传统阻塞式IO的瓶颈在哪里。在连接数不多的情况下,传统IO编写容易方便使用。但是随着连接数的增多,问题传统IO就不行了。因为前面说 过,传统IO处理每个连接都要消耗一个线程,而程序的效率当线程数不多时是随着线程数的增加而增加,但是到一定的数量之后,是随着线程数的增加而减少。这 里我们得出结论,传统阻塞式IO的瓶颈在于不能处理过多的连接。
然后,非阻塞式IO的出现的目的就是为了解决这个瓶颈。而非阻塞式IO 是怎么实现的呢?非阻塞IO处理连接的线程数和连接数没有联系,也就是说处理 10000个连接非阻塞IO不需要10000个线程,你可以用1000个也可以用2000个线程来处理。因为非阻塞IO处理连接是异步的。当某个连接发送 请求到服务器,服务器把这个连接请求当作一个请求"事件",并把这个"事件"分配给相应的函数处理。我们可以把这个处理函数放到线程中去执行,执行完就把 线程归还。这样一个线程就可以异步的处理多个事件。而阻塞式IO的线程的大部分时间都浪费在等待请求上了。
所谓阻塞式IO流,就是指在从数据流当中读写数据的的时候,阻塞当前线程,直到IO流可以
重新使用为止,你也可以使用流的avaliableBytes()函数看看当前流当中有多少字节可以读取,这样
就不会再阻塞了。