程序博客网 > linux more怎么翻页

Java进阶（五）Java I/O模型…

来源：互联网 发布：linux more怎么翻页 编辑：程序博客网 时间：2024/05/17 06:52
http://blog.csdn.net/caiwenfeng_for_23/article/details/8458299
http://www.cnblogs.com/me115/p/4452801.html

Java进阶（五）Java <wbr>I/O模型从BIO到NIO和Reactor模式

http://www.jasongj.com/java/nio_reactor/

 

Unix 下共有五种 I/O 模型：

阻塞 I/O

非阻塞 I/O

I/O 多路复用（select和poll）

信号驱动 I/O（SIGIO）

异步 I/O（Posix.1的aio_系列函数）

 

在高性能的I/O设计中，有两个比较著名的模式Reactor和Proactor模式，其中Reactor模式用于同步I/O，而Proactor运用于异步I/O操作。

同步和异步是相对于应用和内核的交互方式而言的，同步需要主动去询问，而异步的时候内核在IO事件发生的时候通知应用程序，而阻塞和非阻塞仅仅是系统在调用系统调用的时候函数的实现方式而已。


选择器（Selector）

JavaNIO的选择器允许一个单独的线程同时监视多个通道，可以注册多个通道到同一个选择器上，然后使用一个单独的线程来“选择”已经就绪的通道。这种“选择”机制为一个单独线程管理多个通道提供了可能。

零拷贝

JavaNIO中提供的FileChannel拥有transferTo和transferFrom两个方法，可直接把FileChannel中的数据拷贝到另外一个Channel，或者直接把另外一个Channel中的数据拷贝到FileChannel。该接口常被用于高效的网络/文件的数据传输和大文件拷贝。在操作系统支持的情况下，通过该方法传输数据并不需要将源数据从内核态拷贝到用户态，再从用户态拷贝到目标通道的内核态，同时也避免了两次用户态和内核态间的上下文切换，也即使用了“零拷贝”，所以其性能一般高于JavaIO中提供的方法。

使用FileChannel的零拷贝将本地文件内容传输到网络的示例代码如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class NIOClient {
public static voidmain(String[] args) throwsIOException, InterruptedException {
SocketChannel socketChannel= SocketChannel.open();
InetSocketAddress address =newInetSocketAddress(1234);
socketChannel.connect(address);
RandomAccessFile file =newRandomAccessFile(
NIOClient.class.getClassLoader().getResource("test.txt").getFile(),"rw");
FileChannel channel =file.getChannel();
channel.transferTo(0, channel.size(),socketChannel);
channel.close();
file.close();
socketChannel.close();
}
}
 
阻塞I/O下的服务器实现
单线程逐个处理所有请求
使用阻塞I/O的服务器，一般使用循环，逐个接受连接请求并读取数据，然后处理下一个请求。
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
public class IOServer {
private staticfinal Logger LOGGER =LoggerFactory.getLogger(IOServer.class);
public static voidmain(String[] args) {
ServerSocket serverSocket =null;
try {
serverSocket = newServerSocket();
serverSocket.bind(newInetSocketAddress(2345));
} catch (IOException ex){
LOGGER.error("Listen failed",ex);
return;
}
try{
while(true) {
Socket socket =serverSocket.accept();
InputStream inputstream =socket.getInputStream();
LOGGER.info("Received message{}", IOUtils.toString(newInputStreamReader(inputstream)));
}
} catch(IOException ex){
try {
serverSocket.close();
} catch (IOException e){
}
LOGGER.error("Read messagefailed", ex);
}
}
}
 
为每个请求创建一个线程
上例使用单线程逐个处理所有请求，同一时间只能处理一个请求，等待I/O的过程浪费大量CPU资源，同时无法充分使用多CPU的优势。下面是使用多线程对阻塞I/O模型的改进。一个连接建立成功后，创建一个单独的线程处理其I/O操作。
阻塞I/O 多线程
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
public class IOServerMultiThread{
private staticfinal Logger LOGGER =LoggerFactory.getLogger(IOServerMultiThread.class);
public static voidmain(String[] args) {
ServerSocket serverSocket =null;
try {
serverSocket = newServerSocket();
serverSocket.bind(newInetSocketAddress(2345));
} catch (IOException ex){
LOGGER.error("Listen failed",ex);
return;
}
try{
while(true) {
Socket socket =serverSocket.accept();
new Thread( () ->{
try{
InputStream inputstream =socket.getInputStream();
LOGGER.info("Received message{}", IOUtils.toString(newInputStreamReader(inputstream)));
} catch (IOException ex){
LOGGER.error("Read messagefailed", ex);
}
}).start();
}
} catch(IOException ex){
try {
serverSocket.close();
} catch (IOException e){
}
LOGGER.error("Accept connectionfailed", ex);
}
}
}
 
使用线程池处理请求
为了防止连接请求过多，导致服务器创建的线程数过多，造成过多线程上下文切换的开销。可以通过线程池来限制创建的线程数，如下所示。
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
public class IOServerThreadPool{
private staticfinal Logger LOGGER =LoggerFactory.getLogger(IOServerThreadPool.class);
public static voidmain(String[] args) {
ExecutorServiceexecutorService =Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
ServerSocket serverSocket =null;
try {
serverSocket = newServerSocket();
serverSocket.bind(newInetSocketAddress(2345));
} catch (IOException ex){
LOGGER.error("Listen failed",ex);
return;
}
try{
while(true) {
Socket socket =serverSocket.accept();
executorService.submit(()-> {
try{
InputStream inputstream =socket.getInputStream();
LOGGER.info("Received message{}", IOUtils.toString(newInputStreamReader(inputstream)));
} catch (IOException ex){
LOGGER.error("Read messagefailed", ex);
}
});
}
} catch(IOException ex){
try {
serverSocket.close();
} catch (IOException e){
}
LOGGER.error("Accept connectionfailed", ex);
}
}
}
 
Reactor模式
精典Reactor模式
精典的Reactor模式示意图如下所示。
精典Reactor
在Reactor模式中，包含如下角色
  • Reactor 将I/O事件发派给对应的Handler
  • Acceptor 处理客户端连接请求
  • Handlers 执行非阻塞读/写
最简单的Reactor模式实现代码如下所示。
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
public class NIOServer {
private staticfinal Logger LOGGER =LoggerFactory.getLogger(NIOServer.class);
public static voidmain(String[] args) throwsIOException {
Selector selector =Selector.open();
ServerSocketChannelserverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.bind(newInetSocketAddress(1234));
serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
while (selector.select()> 0) {
Set keys =selector.selectedKeys();
Iterator iterator =keys.iterator();
while (iterator.hasNext()){
SelectionKey key =iterator.next();
iterator.remove();
if (key.isAcceptable()){
ServerSocketChannelacceptServerSocketChannel = (ServerSocketChannel)key.channel();
SocketChannel socketChannel= acceptServerSocketChannel.accept();
socketChannel.configureBlocking(false);
LOGGER.info("Accept request from{}", socketChannel.getRemoteAddress());
socketChannel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()){
SocketChannel socketChannel= (SocketChannel) key.channel();
ByteBuffer buffer =ByteBuffer.allocate(1024);
int count =socketChannel.read(buffer);
if (count <=0){
socketChannel.close();
key.cancel();
LOGGER.info("Received invalide data,close the connection");
continue;
}
LOGGER.info("Received message{}", newString(buffer.array()));
}
keys.remove(key);
}
}
}
}
 
为了方便阅读，上示代码将Reactor模式中的所有角色放在了一个类中。
从上示代码中可以看到，多个Channel可以注册到同一个Selector对象上，实现了一个线程同时监控多个请求状态（Channel）。同时注册时需要指定它所关注的事件，例如上示代码中socketServerChannel对象只注册了OP_ACCEPT事件，而socketChannel对象只注册了OP_READ事件。
selector.select()是阻塞的，当有至少一个通道可用时该方法返回可用通道个数。同时该方法只捕获Channel注册时指定的所关注的事件。
多工作线程Reactor模式
经典Reactor模式中，尽管一个线程可同时监控多个请求（Channel），但是所有读/写请求以及对新连接请求的处理都在同一个线程中处理，无法充分利用多CPU的优势，同时读/写操作也会阻塞对新连接请求的处理。因此可以引入多线程，并行处理多个读/写操作，如下图所示。
多线程Reactor
多线程Reactor模式示例代码如下所示。
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
public class NIOServer {
private staticfinal Logger LOGGER =LoggerFactory.getLogger(NIOServer.class);
public static voidmain(String[] args) throwsIOException {
Selector selector =Selector.open();
ServerSocketChannelserverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.bind(newInetSocketAddress(1234));
serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
while (true) {
if(selector.selectNow()< 0) {
continue;
}
Set keys =selector.selectedKeys();
Iterator iterator =keys.iterator();
while(iterator.hasNext()){
SelectionKey key =iterator.next();
iterator.remove();
if (key.isAcceptable()){
ServerSocketChannelacceptServerSocketChannel = (ServerSocketChannel)key.channel();
SocketChannel socketChannel= acceptServerSocketChannel.accept();
socketChannel.configureBlocking(false);
LOGGER.info("Accept request from{}", socketChannel.getRemoteAddress());
SelectionKey readKey =socketChannel.register(selector, SelectionKey.OP_READ);
readKey.attach(newProcessor());
} else if (key.isReadable()){
Processor processor =(Processor) key.attachment();
processor.process(key);
}
}
}
}
}
 
从上示代码中可以看到，注册完SocketChannel的OP_READ事件后，可以对相应的SelectionKeyattach一个对象（本例中attach了一个Processor对象，该对象处理读请求），并且在获取到可读事件后，可以取出该对象。
注：attach对象及取出该对象是NIO提供的一种操作，但该操作并非Reactor模式的必要操作，本文使用它，只是为了方便演示NIO的接口。
具体的读请求处理在如下所示的Processor类中。该类中设置了一个静态的线程池处理所有请求。而process方法并不直接处理I/O请求，而是把该I/O操作提交给上述线程池去处理，这样就充分利用了多线程的优势，同时将对新连接的处理和读/写操作的处理放在了不同的线程中，读/写操作不再阻塞对新连接请求的处理。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Processor {
private staticfinal Logger LOGGER =LoggerFactory.getLogger(Processor.class);
private staticfinal ExecutorService service =Executors.newFixedThreadPool(16);
public void process(SelectionKeyselectionKey) {
service.submit(() ->{
ByteBuffer buffer =ByteBuffer.allocate(1024);
SocketChannel socketChannel= (SocketChannel) selectionKey.channel();
int count =socketChannel.read(buffer);
if (count <0){
socketChannel.close();
selectionKey.cancel();
LOGGER.info("{}\t Read ended",socketChannel);
return null;
} else if(count == 0) {
return null;
}
LOGGER.info("{}\t Read message{}", socketChannel, newString(buffer.array()));
return null;
});
}
}
多Reactor
Netty中使用的Reactor模式，引入了多Reactor，也即一个主Reactor负责监控所有的连接请求，多个子Reactor负责监控并处理读/写请求，减轻了主Reactor的压力，降低了主Reactor压力太大而造成的延迟。
并且每个子Reactor分别属于一个独立的线程，每个成功连接后的Channel的所有操作由同一个线程处理。这样保证了同一请求的所有状态和上下文在同一个线程中，避免了不必要的上下文切换，同时也方便了监控请求响应状态。
多Reactor模式示意图如下所示。
多Reactor
多Reactor示例代码如下所示。
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
public class NIOServer {
private staticfinal Logger LOGGER =LoggerFactory.getLogger(NIOServer.class);
public static voidmain(String[] args) throwsIOException {
Selector selector =Selector.open();
ServerSocketChannelserverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.bind(newInetSocketAddress(1234));
serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
int coreNum =Runtime.getRuntime().availableProcessors();
Processor[] processors =newProcessor[coreNum];
for (int i = 0; i <processors.length; i++) {
processors[i] =newProcessor();
}
int index = 0;
while (selector.select()> 0) {
Set keys =selector.selectedKeys();
for (SelectionKey key :keys) {
keys.remove(key);
if (key.isAcceptable()){
ServerSocketChannelacceptServerSocketChannel = (ServerSocketChannel)key.channel();
SocketChannel socketChannel= acceptServerSocketChannel.accept();
socketChannel.configureBlocking(false);
LOGGER.info("Accept request from{}", socketChannel.getRemoteAddress());
Processor processor =processors[(int) ((index++) /coreNum)];
processor.addChannel(socketChannel);
}
}
}
}
}
 
如上代码所示，本文设置的子Reactor个数是当前机器可用核数的两倍（与Netty默认的子Reactor个数一致）。对于每个成功连接的SocketChannel，通过roundrobin的方式交给不同的子Reactor。
子Reactor对SocketChannel的处理如下所示。
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
public class Processor {
private staticfinal Logger LOGGER =LoggerFactory.getLogger(Processor.class);
private staticfinal ExecutorService service=
Executors.newFixedThreadPool(2 *Runtime.getRuntime().availableProcessors());
private Selectorselector;
public Processor() throwsIOException {
this.selector =SelectorProvider.provider().openSelector();
start();
}
public void addChannel(SocketChannelsocketChannel) throwsClosedChannelException {
socketChannel.register(this.selector,SelectionKey.OP_READ);
}
public void start() {
service.submit(() ->{
while (true) {
if (selector.selectNow()<= 0) {
continue;
}
Set keys =selector.selectedKeys();
Iterator iterator =keys.iterator();
while (iterator.hasNext()){
SelectionKey key =iterator.next();
iterator.remove();
if (key.isReadable()){
ByteBuffer buffer =ByteBuffer.allocate(1024);
SocketChannel socketChannel= (SocketChannel) key.channel();
int count =socketChannel.read(buffer);
if (count <0){
socketChannel.close();
key.cancel();
LOGGER.info("{}\t Read ended",socketChannel);
continue;
} else if (count == 0) {
LOGGER.info("{}\t Message size is0", socketChannel);
continue;
} else {
LOGGER.info("{}\t Read message{}", socketChannel, newString(buffer.array()));
}
}
}
}
});
}
}
 
在Processor中，同样创建了一个静态的线程池，且线程池的大小为机器核数的两倍。每个Processor实例均包含一个Selector实例。同时每次获取Processor实例时均提交一个任务到该线程池，并且该任务正常情况下一直循环处理，不会停止。而提交给该Processor的SocketChannel通过在其Selector注册事件，加入到相应的任务中。由此实现了每个子Reactor包含一个Selector对象，并由一个独立的线程处理。




                                             
        0        0           
	
				
		









 linux more怎么翻页
    		linux more怎么翻页



原创粉丝点击



		

热门IT博客


java如何防止刷赞java如何防止刷赞




yum 正在尝试其它镜像yum 正在尝试其它镜像




算法怎么入门




无网络监控




转基因知乎




java web docker镜像




mysql myisam 事务




sql字符串转数字




月薪一万 知乎




excel数据模拟运算




mac下redis可视化工具




知乎lol与dota2




cf一直网络出现异常




柯蓝 知乎




未注册域名查询软件




复旦大数据学院 课程




linux vim 复制




php7 pdo mysql扩展




mysql case when else




单片机实验箱



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    深圳玩的地方
    深圳旅游景点一日游
    深圳汽车客运站
    深圳购物去哪里
    深圳西火车站在哪里
    深圳路线查询
    深圳高楼排名
    深圳情侣必去景点
    深圳站在哪里
    深圳高铁站在哪里
    深圳特产小吃
    深圳购物中心
    深圳到香港地铁价格
    深圳游玩攻略
    深圳工资高吗
    深圳做什么工资高
    去深圳打工怎么样
    深圳有什么大学
    深圳工厂招聘普工
    深圳消费水平
    深圳有什么好吃的
    深圳离香港有多远
    深圳服装批发市场大全
    深圳什么厂工资高
    深圳公交乘车线路查询
    深圳区域划分图
    深圳离广州多远
    深圳人才招聘网
    深圳公交车查询
    深圳有什么地方
    深圳景点推荐
    深圳有多少个区
    深圳有多少人口
    深圳电子厂招工
    深圳到处一游必去之地
    深圳公交线路查询
    深圳车祸今天
    深圳仁爱医院地址
    深圳坐车网公交车查询
    深圳第一现场重播
    深圳东火车站


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里