NIO简介:与Socket和ServerSocket类相对应,NIO提供了SocketChannel和ServerSocketChannel两种不同的套接字通道实现,这两种新通道都支持阻塞和非阻塞两种模式。阻塞模式使用简单,但是性能和可靠性不好,非阻塞模式正好相反。

  1.缓冲区Buffer:一个对象,包含一些要写入或要读出的数据。任何时候访问NIO中数据,都是通过缓冲区进行操作。缓冲区实质是一个数据,最常用的缓冲区是ByteBuffer。每一种Java基本类型都对应一种缓冲区,如ByteBuffer字节缓冲区、CharBuffer字符缓冲区、ShortBuffer短整型缓冲区、IntBuffer整型缓冲区、LongBuffer长整型缓冲区、FloatBuffer浮点型缓冲区、DoubleBuffer双精度浮点型缓冲区

  2.通道Channel:Channel是一个通道,网络数据通过Channel读取和写入。Channel可以用于读取和写入同时进行,因为通道是全双工的,而流只是在一个方向上移动(一个流必须是InputStream或者OutputStream的子类)。Channel可以分为两大类,用于网络读写的SelectableChannel和用于文件操作的FileChannel

  3.多路复用器Selector:Selector会不断的轮询注册在其上的Channel,如果某个Channel上面发生读或者写事件,这个Channel就处于就绪状态,会被Selector轮询出来,然后通过SelectionKey可以获取就绪Channel的集合,进行后续的I/O操作。一个多路复用器Selector可以同时轮询多个Channel,由于JDK使用了epoll()代替传统的select实现,所以它并没有最大连接句柄1024/2048的限制,意味着一个线程负责Selector的轮询,就可以接入成千上万的客户端

如果发送区TCP缓冲区满,会导致写半包,此时,需要注册监听写操作位,循环写,直到整包消息写入TCP缓冲区

Server对应Accept,Client对应Connection

  1. package com.hjp.netty.nio;
  2.  
  3. import java.io.IOException;
  4.  
  5. public class TimeServer {
  6.  
  7. public static void main(String[] args) throws IOException {
  8. int port = 8080;
  9. if (args != null && args.length > 0) {
  10. try {
  11. port = Integer.valueOf(port);
  12. } catch (NumberFormatException e) {
  13. e.printStackTrace();
  14. }
  15. }
  16. //创建多路复用类,一个独立线程,负责轮询多路复用器Selector,可以处理多个客户端的并发接入
  17. MultiplexerTimeServer timeServer = new MultiplexerTimeServer(port);
  18. new Thread(timeServer, "NIO-MultiplexerTimeServer-001").start();
  19. }
  20.  
  21. }

TimeServer

  1. package com.hjp.netty.nio;
  2.  
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import java.nio.ByteBuffer;
  6. import java.nio.channels.SelectionKey;
  7. import java.nio.channels.Selector;
  8. import java.nio.channels.ServerSocketChannel;
  9. import java.nio.channels.SocketChannel;
  10. import java.util.Date;
  11. import java.util.Iterator;
  12. import java.util.Set;
  13.  
  14. public class MultiplexerTimeServer implements Runnable {
  15.  
  16. private Selector selector;
  17.  
  18. private ServerSocketChannel serverChannel;
  19.  
  20. private volatile boolean stop;
  21.  
  22. /**
  23. * 初始化多路复用器,绑定监听端口
  24. *
  25. * @param port
  26. */
  27. public MultiplexerTimeServer(int port) {
  28. try {
  29. selector = Selector.open();
  30. serverChannel = ServerSocketChannel.open();
  31. serverChannel.configureBlocking(false);
  32. serverChannel.socket().bind(new InetSocketAddress(port), 1024);
  33. serverChannel.register(selector, SelectionKey.OP_ACCEPT);
  34. System.out.println("The time server is start in port : " + port);
  35. } catch (IOException e) {
  36. e.printStackTrace();
  37. System.exit(1);
  38. }
  39. }
  40.  
  41. public void stop() {
  42. this.stop = true;
  43. }
  44.  
  45. @Override
  46. public void run() {
  47. while (!stop) {
  48. try {
  49. selector.select(1000);//休眠一秒
  50. Set<SelectionKey> selectedKeys = selector.selectedKeys();
  51. Iterator<SelectionKey> it = selectedKeys.iterator();
  52. SelectionKey key = null;
  53. while (it.hasNext()) {
  54. key = it.next();
  55. it.remove();
  56. try {
  57. handleInput(key);
  58. } catch (Exception e) {
  59. if (key != null) {
  60. key.cancel();
  61. if (key.channel() != null) {
  62. key.channel().close();
  63. }
  64. }
  65. }
  66. }
  67. } catch (Throwable t) {
  68. t.printStackTrace();
  69. }
  70. }
  71. //多路复用器关闭后,所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭,所有不需要重复释放资源
  72. if (selector != null) {
  73. try {
  74. selector.close();
  75. } catch (IOException e) {
  76. e.printStackTrace();
  77. }
  78. }
  79. }
  80.  
  81. private void handleInput(SelectionKey key) throws IOException {
  82. if (key.isValid()) {
  83. //处理新接入的请求消息
  84. if (key.isAcceptable()) {
  85. //Accept the new connection
  86. ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
  87. SocketChannel sc = ssc.accept();
  88. sc.configureBlocking(false);
  89. //Add the new connection to the selector
  90. sc.register(selector, SelectionKey.OP_READ);
  91. }
  92. if (key.isReadable()) {
  93. //Read the data
  94. SocketChannel sc = (SocketChannel) key.channel();
  95. ByteBuffer readBuffer = ByteBuffer.allocate(1024);
  96. int readBytes = sc.read(readBuffer);
  97. if (readBytes > 0) {
  98. readBuffer.flip();
  99. byte[] bytes = new byte[readBuffer.remaining()];
  100. readBuffer.get(bytes);
  101. String body = new String(bytes, "UTF-8");
  102. System.out.println("The time server receive order : " + body);
  103. String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
  104. doWrite(sc, currentTime);
  105. } else if (readBytes < 0) {
  106. //对端链路关闭
  107. key.cancel();
  108. sc.close();
  109. } else {
  110. ;//读到0字节,忽略
  111. }
  112. }
  113. }
  114. }
  115.  
  116. private void doWrite(SocketChannel channel, String response) throws IOException {
  117. if (response != null && response.trim().length() > 0) {
  118. byte[] bytes = response.getBytes();
  119. ByteBuffer writeBuffer=ByteBuffer.allocate(bytes.length);
  120. writeBuffer.put(bytes);
  121. writeBuffer.flip();
  122. channel.write(writeBuffer);
  123. }
  124. }
  125. }

多路复用器类

  1. package com.hjp.netty.nio;
  2.  
  3. import java.io.IOException;
  4.  
  5. public class TimeClient {
  6.  
  7. public static void main(String[] args) throws IOException {
  8. int port = 8080;
  9. if (args != null && args.length > 0) {
  10. try {
  11. port = Integer.valueOf(args[0]);
  12. } catch (NumberFormatException e) {
  13. e.printStackTrace();
  14. }
  15. }
  16. new Thread(new TimeClientHandler("127.0.0.1",port),"TimeClient-001").start();
  17. }
  18.  
  19. }

TimeClient

  1. package com.hjp.netty.nio;
  2.  
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import java.nio.ByteBuffer;
  6. import java.nio.channels.SelectableChannel;
  7. import java.nio.channels.SelectionKey;
  8. import java.nio.channels.Selector;
  9. import java.nio.channels.SocketChannel;
  10. import java.util.Iterator;
  11. import java.util.Set;
  12.  
  13. public class TimeClientHandler implements Runnable {
  14.  
  15. private String host;
  16. private int port;
  17. private Selector selector;
  18. private SocketChannel socketChannel;
  19. private volatile boolean stop;
  20.  
  21. public TimeClientHandler(String host, int port) {
  22. this.host = host == null ? "127.0.0.1" : host;
  23. this.port = port;
  24. try {
  25. selector = Selector.open();
  26. socketChannel = SocketChannel.open();
  27. socketChannel.configureBlocking(false);
  28. } catch (IOException e) {
  29. e.printStackTrace();
  30. System.exit(1);
  31. }
  32. }
  33.  
  34. @Override
  35. public void run() {
  36. try {
  37. doConnect();
  38. } catch (IOException e) {
  39. e.printStackTrace();
  40. System.exit(1);
  41. }
  42. while (!stop) {
  43. try {
  44. selector.select(1000);
  45. Set<SelectionKey> selectedKeys = selector.selectedKeys();
  46. Iterator<SelectionKey> it = selectedKeys.iterator();
  47. SelectionKey key = null;
  48. while (it.hasNext()) {
  49. key = it.next();
  50. it.remove();
  51. try {
  52. handleInput(key);
  53. } catch (Exception e) {
  54. if (key != null) {
  55. key.cancel();
  56. if (key.channel() != null) {
  57. key.channel().close();
  58. }
  59. }
  60. }
  61. }
  62. } catch (Exception e) {
  63. e.printStackTrace();
  64. System.exit(1);
  65. }
  66. }
  67. //多路复用器关闭后,所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭,所以不需要重复释放资源
  68. if (selector != null) {
  69. try {
  70. selector.close();
  71. } catch (IOException e) {
  72. e.printStackTrace();
  73. }
  74. }
  75. }
  76.  
  77. private void handleInput(SelectionKey key) throws IOException {
  78. if (key.isValid()) {
  79. //判断是否连接成功
  80. SocketChannel sc = (SocketChannel) key.channel();
  81. if (key.isConnectable()) {
  82. if (sc.finishConnect()) {
  83. sc.register(selector, SelectionKey.OP_READ);
  84. doWrite(sc);
  85. } else {
  86. System.exit(1);//连接失败进程退出
  87. }
  88. }
  89. if (key.isReadable()) {
  90. ByteBuffer readBuffer = ByteBuffer.allocate(1024);
  91. int readBytes = sc.read(readBuffer);
  92. if (readBytes > 0) {
  93. readBuffer.flip();
  94. byte[] bytes = new byte[readBuffer.remaining()];
  95. readBuffer.get(bytes);
  96. String body = new String(bytes, "UTF-8");
  97. System.out.println("Now is : " + body);
  98. this.stop = true;
  99. } else if (readBytes < 0) {
  100. //对端链路关闭
  101. key.cancel();
  102. sc.close();
  103. } else {
  104. ;//对到0字节,忽略
  105. }
  106. }
  107. }
  108. }
  109.  
  110. private void doConnect() throws IOException {
  111. //如果直接连接成功,则注册到多路复用器上,发送请求消息,读应答
  112. if (socketChannel.connect(new InetSocketAddress(host, port))) {
  113. socketChannel.register(selector, SelectionKey.OP_READ);
  114. doWrite(socketChannel);
  115. } else {
  116. socketChannel.register(selector, SelectionKey.OP_CONNECT);
  117. }
  118. }
  119.  
  120. private void doWrite(SocketChannel sc) throws IOException {
  121. byte[] req = "QUERY TIME ORDER".getBytes();
  122. ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
  123. writeBuffer.put(req);
  124. writeBuffer.flip();
  125. sc.write(writeBuffer);
  126. if (!writeBuffer.hasRemaining()) {
  127. System.out.println("Send order 2 server succeed.");
  128. }
  129. }
  130. }

TimeClientHandler

Netty权威指南之NIO通信模型的更多相关文章

  1. Netty权威指南

    Netty权威指南(异步非阻塞通信领域的经典之作,国内首本深入剖析Netty的著作,全面系统讲解原理.实战和源码,带你完美进阶Netty工程师.) 李林锋 著   ISBN 978-7-121-233 ...

  2. 《Netty权威指南》

    <Netty权威指南> 基本信息 作者: 李林锋 出版社:电子工业出版社 ISBN:9787121233432 上架时间:2014-5-29 出版日期:2014 年6月 开本:16开 页码 ...

  3. 《Netty 权威指南(第2 版)》目录

    图书简介:<Netty 权威指南(第2 版)>是异步非阻塞通信领域的经典之作,基于最新版本的Netty 5.0 编写,是国内很难得一见的深入介绍Netty 原理和架构的书籍,也是作者多年实 ...

  4. netty权威指南学习笔记六——编解码技术之MessagePack

    编解码技术主要应用在网络传输中,将对象比如BOJO进行编解码以利于网络中进行传输.平常我们也会将编解码说成是序列化/反序列化 定义:当进行远程跨进程服务调用时,需要把被传输的java对象编码为字节数组 ...

  5. netty权威指南学习笔记二——netty入门应用

    经过了前面的NIO基础知识准备,我们已经对NIO有了较大了解,现在就进入netty的实际应用中来看看吧.重点体会整个过程. 按照权威指南写程序的过程中,发现一些问题:当我们在定义handler继承Ch ...

  6. Netty权威指南之AIO编程

    由JDK1.7提供的NIO2.0新增了异步的套接字通道,它是真正的异步I/O,在异步I/O操作的时候可以传递信号变量,当操作完成后会回调相关的方法,异步I/o也被称为AIO,对应于UNIX网络编程中的 ...

  7. 《Netty权威指南》(二)NIO 入门

    [TOC]   2.1 同步阻塞 I/O 采用 BIO 通信模型的服务器,通常由一个独立的 Acceptor 线程负责监听客户端的连接,它接收到客户端连接请求之后为每个客户端创建一个新的线程进行处理, ...

  8. Netty权威指南之BIO(Block Input/Output,同步阻塞I/O通信)通信模型

    网络编程的基本模型是Client/Server模型,也就是两个进程之间进行相互通信,其中服务端提供位置信息(绑定的IP地址和监听端口),客户端通过连接操作向服务端监听的地址发起连接请求,通过三次握手建 ...

  9. netty权威指南学习笔记一——NIO入门(1)BIO

    公司的一些项目采用了netty框架,为了加速适应公司开发,本博主认真学习netty框架,前一段时间主要看了看书,发现编程这东西,不上手还是觉得差点什么,于是为了加深理解,深入学习,本博主还是决定多动手 ...

随机推荐

  1. Maven打包生成源码包和Javadoc包

    https://blog.csdn.net/top_code/article/details/53586551 当我们开发了一个公共模块,将它deploy到Maven仓库时,最好同时提供源码包和Jav ...

  2. Java设计模式(19)状态模式(State模式)

    State的定义:不同的状态,不同的行为:或者说,每个状态有着相应的行为. 何时使用状态模式 State模式在实际使用中比较多,适合"状态的切换".因为我们经常会使用If else ...

  3. 《Scrum实战》读书会作业01 - 用知行视角总结现在或者过去的一个项目

    下面是<Scrum实战>读书会的第1个作业,主要是用知行视角来总结回顾现在或者过去的一个项目. 项目背景 2011年初,我做的项目是一个搜索引擎相关的项目,这个项目为公司在全球范围内的金融 ...

  4. 【转】jmeter 如何将上一个请求的结果作为下一个请求的参数——使用正则提取器

    1.简介 Apache JMeter是Apache组织开发的基于Java的压力测试工具.用于对软件做压力测试,它最初被设计用于Web应用测试但后来扩展到其他测试领域. 它可以用于测试静态和动态资源例如 ...

  5. Sword pcre库函数学习三

    14.pcre_get_substring_list 原型: #include <pcre.h> int pcre_get_substring_list(const char *subje ...

  6. Linux 下用管道执行 ps aux | grep 进程ID 来获取CPU与内存占用率

    #include <stdio.h> #include <unistd.h>   int main() {     char caStdOutLine[1024]; // ps ...

  7. tensorflow prelu的实现细节

    tensorflow prelu的实现细节 output = tf.nn.leaky_relu(input, alpha=tf_gamma_data,name=name) #tf.nn.leaky_r ...

  8. Couchbase 集群小实践

    局域网 两台机  192.168.1.2  我们称为A机器   192.168.1.3   我们称为B机器   配置集群的时候,从A或者是B的web后台都可以添加, 在这里 我们以 A机器为主   目 ...

  9. perl 安装Image::Magick 模块

    ImageMagick 是一个处理图片的库,有C, perl, python, java 等多种语言对应的库 在安装perl 对应的Image::Magick 模块之前,首先需要安装 ImgeMagi ...

  10. Springmvc 的post请求的json格式参数

    背景: 这两天在项目中遇到了一个问题.我的环境是springmvc4.1.9,写了几个可以用ajax请求的接口(ajax.jsonp 调用正常).突然一时兴起就用 HTTP 请求的工具(比如火狐浏览器 ...