JAVA【Netty】第一讲
Netty简介
- Netty 的介绍
- Netty 的应用场景
- 互联网行业
- 游戏行业
- 大数据领域
- 其它开源项目使用到 Netty
- Netty 的学习资料参考
- Java BIO编程
- I/O 模型
- BIO、NIO、AIO 使用场景分析
- Java BIO 基本介绍
- Java BIO 工作机制
- Java BIO 应用实例
- 问题分析
- Java NIO编程
- Java NIO 基本介绍
- NIO 和 BIO 的比较
- NIO 三大核心原理示意图
- Selector、Channel 和 Buffer 关系图(简单版)
- 缓冲区(Buffer)
- 基本介绍
- Buffer 类及其子类
- ByteBuffer
- 通道(Channel)
- 基本介绍
- FileChannel 类
- 应用实例1 - 本地文件写数据
- 应用实例2 - 本地文件读数据
- 应用实例3 - 使用一个 Buffer 完成文件读取、写入
- 应用实例4 - 拷贝文件 transferFrom 方法
- 关于 Buffer 和 Channel 的注意事项和细节
- Selector(选择器)
- 基本介绍
- Selector 示意图和特点说明
- Selector 类相关方法
- 注意事项
- NIO 非阻塞网络编程原理分析图
- NIO 非阻塞网络编程快速入门
- SelectionKey
- ServerSocketChannel
- SocketChannel
- NIO网络编程应用实例 - 群聊系统
- NIO与零拷贝
- 零拷贝基本介绍
- 传统 IO 数据读写
- 传统 IO 模型
- mmap 优化
- sendFile 优化
- 零拷贝的再次理解
- mmap 和 sendFile 的区别
- NIO 零拷贝案例
- Java AIO 基本介绍
- BIO、NIO、AIO 对比表
Netty简介
Netty 的介绍
Netty
是由JBOSS
提供的一个Java
开源框架,现为Github
上的独立项目。Netty
是一个异步的、基于事件驱动的网络应用框架,用以快速开发高性能、高可靠性的网络IO
程序。Netty
主要针对在TCP
协议下,面向Client
端的高并发应用,或者Peer-to-Peer
场景下的大量数据持续传输的应用。Netty
本质是一个NIO
框架,适用于服务器通讯相关的多种应用场景。- 要透彻理解
Netty
,需要先学习NIO
,这样我们才能阅读Netty
的源码。
相对简单的一个体系图
Netty 的应用场景
互联网行业
- 互联网行业:在分布式系统中,各个节点之间需要远程服务调用,高性能的
RPC
框架必不可少,Netty
作为异步高性能的通信框架,往往作为基础通信组件被这些RPC
框架使用。 - 典型的应用有:阿里分布式服务框架
Dubbo
的RPC
框 架使用Dubbo
协议进行节点间通信,Dubbo
协议默认使用Netty
作为基础通信组件,用于实现各进程节点之间的内部通信。
游戏行业
- 无论是手游服务端还是大型的网络游戏,
Java
语言得到了越来越广泛的应用。 Netty
作为高性能的基础通信组件,提供了TCP/UDP
和HTTP
协议栈,方便定制和开发私有协议栈,账号登录服务器。- 地图服务器之间可以方便的通过
Netty
进行高性能的通信。
大数据领域
- 经典的
Hadoop
的高性能通信和序列化组件Avro
的RPC
框架,默认采用Netty
进行跨界点通信。 - 它的
NettyService
基于Netty
框架二次封装实现。
其它开源项目使用到 Netty
网址:https://netty.io/wiki/related-projects.html
Netty 的学习资料参考
Java BIO编程
I/O 模型
I/O
模型简单的理解:就是用什么样的通道进行数据的发送和接收,很大程度上决定了程序通信的性能。Java
共支持3
种网络编程模型I/O
模式:BIO
、NIO
、AIO
。Java BIO
:同步并阻塞(传统阻塞型),服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销。【简单示意图】
Java NIO
:同步非阻塞,服务器实现模式为一个线程处理多个请求(连接),即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O
请求就进行处理。【简单示意图】
Java AIO(NIO.2)
:异步非阻塞,AIO
引入异步通道的概念,采用了Proactor
模式,简化了程序编写,有效的请求才启动线程,它的特点是先由操作系统完成后才通知服务端程序启动线程去处理,一般适用于连接数较多且连接时间较长的应用。- 我们依次展开讲解。
BIO、NIO、AIO 使用场景分析
BIO
方式适用于连接数目比较小且固定的架构,这种方式对服务器资源要求比较高,并发局限于应用中,JDK1.4
以前的唯一选择,但程序简单易理解。NIO
方式适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器,弹幕系统,服务器间通讯等。编程比较复杂,JDK1.4
开始支持。AIO
方式使用于连接数目多且连接比较长(重操作)的架构,比如相册服务器,充分调用OS
参与并发操作,编程比较复杂,JDK7
开始支持。
Java BIO 基本介绍
Java BIO
就是传统的Java I/O
编程,其相关的类和接口在java.io
。BIO(BlockingI/O)
:同步阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,可以通过线程池机制改善(实现多个客户连接服务器)。【后有应用实例】BIO
方式适用于连接数目比较小且固定的架构,这种方式对服务器资源要求比较高,并发局限于应用中,JDK1.4
以前的唯一选择,程序简单易理解。
Java BIO 工作机制
对 BIO
编程流程的梳理
- 服务器端启动一个
ServerSocket
。 - 客户端启动
Socket
对服务器进行通信,默认情况下服务器端需要对每个客户建立一个线程与之通讯。 - 客户端发出请求后,先咨询服务器是否有线程响应,如果没有则会等待,或者被拒绝。
- 如果有响应,客户端线程会等待请求结束后,再继续执行。
Java BIO 应用实例
实例说明:
- 使用
BIO
模型编写一个服务器端,监听6666
端口,当有客户端连接时,就启动一个线程与之通讯。 - 要求使用线程池机制改善,可以连接多个客户端。
- 服务器端可以接收客户端发送的数据(
telnet
方式即可)。 - 代码演示:
package com.qf.bio;import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class SocketServer {public static void main(String[] args) {//线程池的机制,每有一个客户端连接,就创建一个线程与之连接ExecutorService executor = Executors.newCachedThreadPool();try {ServerSocket server = new ServerSocket(6622);System.out.println("服务器启动了");while(true){System.out.println("等待连接...");final Socket accept = server.accept();System.out.println("连接到了一个客户端");executor.execute(new Runnable() {public void run() {System.out.println("当前线程的id:"+Thread.currentThread().getId()+"当前线程的名字:"+Thread.currentThread().getName() );handler(accept);}});}} catch (IOException e) {e.printStackTrace();}}public static void handler(Socket accept){byte[] bytes=new byte[1024];try {InputStream inputStream = accept.getInputStream();System.out.println("等到阅读...");while (true){int read = inputStream.read(bytes);if (read!=-1){System.out.println(new java.lang.String(bytes,0,read,"utf-8"));}else{break;}}}catch (Exception e){e.printStackTrace();}finally {try {accept.close();} catch (IOException e) {e.printStackTrace();}}}
}
telnet 127.0.0.1 6622
问题分析
- 每个请求都需要创建独立的线程,与对应的客户端进行数据
Read
,业务处理,数据Write
。 - 当并发数较大时,需要创建大量线程来处理连接,系统资源占用较大。
- 连接建立后,如果当前线程暂时没有数据可读,则线程就阻塞在
Read
操作上,造成线程资源浪费。
Java NIO编程
Java NIO 基本介绍
Java NIO
全称Java non-blocking IO
,是指JDK
提供的新API
。从JDK1.4
开始,Java
提供了一系列改进的输入/输出的新特性,被统称为NIO
(即NewIO
),是同步非阻塞的。NIO
相关类都被放在java.nio
包及子包下,并且对原java.io
包中的很多类进行改写。【基本案例】NIO
有三大核心部分:Channel
(通道)、Buffer
(缓冲区)、Selector
(选择器) 。NIO
是面向缓冲区,或者面向块编程的。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动,这就增加了处理过程中的灵活性,使用它可以提供非阻塞式的高伸缩性网络。Java NIO
的非阻塞模式,使一个线程从某通道发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。【后面有案例说明】- 通俗理解:
NIO
是可以做到用一个线程来处理多个操作的。假设有10000
个请求过来,根据实际情况,可以分配50
或者100
个线程来处理。不像之前的阻塞IO
那样,非得分配10000
个。 HTTP 2.0
使用了多路复用的技术,做到同一个连接并发处理多个请求,而且并发请求的数量比HTTP 1.1
大了好几个数量级。- 案例说明
NIO
的Buffer
package com.qf.nio;import java.nio.IntBuffer;public class BasicNio {public static void main(String[] args) {IntBuffer intBuffer = IntBuffer.allocate(5);for (int i = 0; i < intBuffer.capacity(); i++) {intBuffer.put(i*2);}intBuffer.flip();intBuffer.position(2);intBuffer.limit(3);intBuffer.clear();while (intBuffer.hasRemaining()){System.out.println(intBuffer.get());}}
}
NIO 和 BIO 的比较
BIO
以流的方式处理数据,而NIO
以块的方式处理数据,块I/O
的效率比流I/O
高很多。BIO
是阻塞的,NIO
则是非阻塞的。BIO
基于字节流和字符流进行操作,而NIO
基于Channel
(通道)和Buffer
(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector
(选择器)用于监听多个通道的事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个客户端通道。- Buffer和Channel之间的数据流向是双向的
NIO 三大核心原理示意图
一张图描述 NIO
的 Selector
、Channel
和 Buffer
的关系。
Selector、Channel 和 Buffer 关系图(简单版)
关系图的说明:
- 每个
Channel
都会对应一个Buffer
。 Selector
对应一个线程,一个线程对应多个Channel
(连接)。- 该图反应了有三个
Channel
注册到该Selector
//程序 - 程序切换到哪个
Channel
是由事件决定的,Event
就是一个重要的概念。 Selector
会根据不同的事件,在各个通道上切换。Buffer
就是一个内存块,底层是有一个数组。- 数据的读取写入是通过
Buffer
,这个和BIO
是不同的,BIO
中要么是输入流,或者是输出流,不能双向,但是NIO
的Buffer
是可以读也可以写,需要flip
方法切换Channel
是双向的,可以返回底层操作系统的情况,比如Linux
,底层的操作系统通道就是双向的。
缓冲区(Buffer)
基本介绍
缓冲区(Buffer
):缓冲区本质上是一个可以读写数据的内存块,可以理解成是一个容器对象(含数组),该对象提供了一组方法,可以更轻松地使用内存块,,缓冲区对象内置了一些机制,能够跟踪和记录缓冲区的状态变化情况。Channel
提供从文件、网络读取数据的渠道,但是读取或写入的数据都必须经由 Buffer
,如图:【后面举例说明】
Buffer 类及其子类
- 在
NIO
中,Buffer
是一个顶层父类,它是一个抽象类,类的层级关系图:
Buffer
类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:
Buffer
类相关方法一览
ByteBuffer
从前面可以看出对于 Java
中的基本数据类型(boolean
除外),都有一个 Buffer
类型与之相对应,最常用的自然是 ByteBuffer
类(二进制数据),该类的主要方法如下:
通道(Channel)
基本介绍
NIO
的通道类似于流,但有些区别如下:
- 通道可以同时进行读写,而流只能读或者只能写
- 通道可以实现异步读写数据
- 通道可以从缓冲读数据,也可以写数据到缓冲:
BIO
中的Stream
是单向的,例如FileInputStream
对象只能进行读取数据的操作,而NIO
中的通道(Channel
)是双向的,可以读操作,也可以写操作。Channel
在NIO
中是一个接口public interface Channel extends Closeable{}
- 常用的
Channel
类有:FileChannel
、DatagramChannel
、ServerSocketChannel
和SocketChannel
。【ServerSocketChanne
类似ServerSocket
、SocketChannel
类似Socket
】 FileChannel
用于文件的数据读写,DatagramChannel
用于UDP
的数据读写,ServerSocketChannel
和SocketChannel
用于TCP
的数据读写。- 图示
FileChannel 类
FileChannel
主要用来对本地文件进行 IO
操作,常见的方法有
public int read(ByteBuffer dst)
,从通道读取数据并放到缓冲区中public int write(ByteBuffer src)
,把缓冲区的数据写到通道中public long transferFrom(ReadableByteChannel src, long position, long count)
,从目标通道中复制数据到当前通道public long transferTo(long position, long count, WritableByteChannel target)
,把数据从当前通道复制给目标通道
应用实例1 - 本地文件写数据
实例要求:
- 使用前面学习后的
ByteBuffer
(缓冲)和FileChannel
(通道),将 “hello,尚硅谷” 写入到file01.txt
中 - 文件不存在就创建
- 代码演示
package com.qf.nio;import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;public class NIOFileChannel01 {public static void main(String[] args) throws IOException {String str="hello,尚硅谷";//文件输出流FileOutputStream fileOutputStream = new FileOutputStream("D:\\zhoutao\\cc.txt");//文件通道FileChannel channel = fileOutputStream.getChannel();//byteBufferByteBuffer byteBuffer = ByteBuffer.allocate(1024);byteBuffer.put(str.getBytes());byteBuffer.flip();//channel与缓冲区绑定,写入到channel中channel.write(byteBuffer);fileOutputStream.close();}
}
应用实例2 - 本地文件读数据
实例要求:
- 使用前面学习后的
ByteBuffer
(缓冲)和FileChannel
(通道),将file01.txt
中的数据读入到程序,并显示在控制台屏幕 - 假定文件已经存在
- 代码演示
package com.qf.nio;import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.FileChannel;public class NIOFileChannel02 {public static void main(String[] args) throws IOException {//创建文件File file=new File("D:\\zhoutao\\cc.txt");//文件输入流FileInputStream inputStream=new FileInputStream(file);//通道FileChannel channel = inputStream.getChannel();ByteBuffer byteBuffer=ByteBuffer.allocate((int) file.length());//将channel里面的数据读入到文件buffer中channel.read(byteBuffer);System.out.println(new String(byteBuffer.array()));inputStream.close();}
}
应用实例3 - 使用一个 Buffer 完成文件读取、写入
实例要求:
- 使用
FileChannel
(通道)和方法read、write
,完成文件的拷贝 - 拷贝一个文本文件
1.txt
,放在项目下即可 - 代码演示
package com.qf.nio;import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;public class NIOFileChannel03 {public static void main(String[] args) throws IOException {//文件输入流和通道File file=new File("D:\\zhoutao\\cc.txt");FileInputStream inputStream = new FileInputStream(file);FileChannel inputChannel = inputStream.getChannel();//文件输出流和通道FileOutputStream outStream = new FileOutputStream("D:\\zhoutao\\dd.txt");FileChannel outChannel = outStream.getChannel();//缓存流,分配空间ByteBuffer byteBuffer=ByteBuffer.allocate((int) file.length());inputChannel.read(byteBuffer);byteBuffer.flip();/* byte[] array = byteBuffer.array();//清空bufferbyteBuffer.clear();byteBuffer.put(array);byteBuffer.flip();*/outChannel.write(byteBuffer);inputStream.close();outStream.close();}
}
应用实例4 - 拷贝文件 transferFrom 方法
- 实例要求:
- 使用
FileChannel
(通道)和方法transferFrom
,完成文件的拷贝 - 拷贝一张图片
- 代码演示
package com.qf.nio;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;public class NIOFileChannel04 {public static void main(String[] args) throws IOException {//文件输入流和channelFileInputStream inputStream = new FileInputStream("D:\\zhoutao\\AACC.jpg");FileChannel inputChannel = inputStream.getChannel();//文件输出流和channelFileOutputStream outputStream=new FileOutputStream("D:\\zhoutao\\BBDD.jpg");FileChannel outChannel = outputStream.getChannel();outChannel.transferFrom(inputChannel,0,inputChannel.size());inputChannel.close();outChannel.close();inputStream.close();outputStream.close();}
}
关于 Buffer 和 Channel 的注意事项和细节
ByteBuffer
支持类型化的put
和get
,put
放入的是什么数据类型,get
就应该使用相应的数据类型来取出,否则可能有BufferUnderflowException
异常。【举例说明】
package com.qf.nio;import java.nio.ByteBuffer;public class NIOBufferPutGet {public static void main(String[] args) {ByteBuffer byteBuffer=ByteBuffer.allocate(1024);byteBuffer.putChar('A');byteBuffer.putInt(12);byteBuffer.putShort((short) 2);byteBuffer.putDouble(2.03D);System.out.println(byteBuffer.getChar());System.out.println(byteBuffer.getInt());System.out.println(byteBuffer.getShort());System.out.println(byteBuffer.getDouble());ByteBuffer byteBuffer1 = byteBuffer.asReadOnlyBuffer();byteBuffer1.put("sasa".getBytes());}
}
2.可以将一个普通 Buffer
转成只读 Buffer
【举例说明】
package com.qf.nio;import java.nio.ByteBuffer;public class NIOBufferPutGet {public static void main(String[] args) {ByteBuffer byteBuffer=ByteBuffer.allocate(1024);byteBuffer.putChar('A');byteBuffer.putInt(12);byteBuffer.putShort((short) 2);byteBuffer.putDouble(2.03D);System.out.println(byteBuffer.getChar());System.out.println(byteBuffer.getInt());System.out.println(byteBuffer.getShort());System.out.println(byteBuffer.getDouble());ByteBuffer byteBuffer1 = byteBuffer.asReadOnlyBuffer();byteBuffer1.put("sasa".getBytes());}
}
3.NIO
还提供了 MappedByteBuffer
,可以让文件直接在内存(堆外的内存)中进行修改,而如何同步到文件由 NIO
来完成。【举例说明】
package com.qf.nio;import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;public class NIOMapperBuffer {public static void main(String[] args) throws IOException {RandomAccessFile randomAccessFile = new RandomAccessFile("D:\\zhoutao\\dd.txt","rw");FileChannel channel = randomAccessFile.getChannel();MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);mappedByteBuffer.put(0, (byte) 'D');mappedByteBuffer.put(3, (byte) 8);randomAccessFile.close();}
}
4.前面我们讲的读写操作,都是通过一个 Buffer
完成的,NIO
还支持通过多个 Buffer
(即 Buffer
数组)完成读写操作,即 Scattering
和 Gathering
【举例说明】
package com.qf.nio;import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;/*** Scattering:将数据写入到 buffer 时,可以采用 buffer 数组,依次写入 [分散]* Gathering:从 buffer 读取数据时,可以采用 buffer 数组,依次读*/
public class ScatteringAndGatheringTest {public static void main(String[] args) throws Exception {//使用 ServerSocketChannel 和 SocketChannel 网络ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);//绑定端口到 socket,并启动serverSocketChannel.socket().bind(inetSocketAddress);//创建 buffer 数组ByteBuffer[] byteBuffers = new ByteBuffer[2];byteBuffers[0] = ByteBuffer.allocate(5);byteBuffers[1] = ByteBuffer.allocate(3);//等客户端连接 (telnet)SocketChannel socketChannel = serverSocketChannel.accept();int messageLength = 8; //假定从客户端接收 8 个字节//循环的读取while (true) {int byteRead = 0;while (byteRead < messageLength) {long l = socketChannel.read(byteBuffers);byteRead += l; //累计读取的字节数System.out.println("byteRead = " + byteRead);//使用流打印,看看当前的这个 buffer 的 position 和 limitArrays.asList(byteBuffers).stream().map(buffer -> "position = " + buffer.position() + ", limit = " + buffer.limit()).forEach(System.out::println);}//将所有的 buffer 进行 flipArrays.asList(byteBuffers).forEach(buffer -> buffer.flip());//将数据读出显示到客户端long byteWirte = 0;while (byteWirte < messageLength) {long l = socketChannel.write(byteBuffers);//byteWirte += l;}//将所有的buffer进行clearArrays.asList(byteBuffers).forEach(buffer -> {buffer.clear();});System.out.println("byteRead = " + byteRead + ", byteWrite = " + byteWirte + ", messagelength = " + messageLength);}}
}
Selector(选择器)
基本介绍
Java
的NIO
,用非阻塞的IO
方式。可以用一个线程,处理多个的客户端连接,就会使用到Selector
(选择器)。Selector
能够检测多个注册的通道上是否有事件发生(注意:多个Channel
以事件的方式可以注册到同一个Selector
),如果有事件发生,便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道,也就是管理多个连接和请求。- 只有在连接/通道真正有读写事件发生时,才会进行读写,就大大地减少了系统开销,并且不必为每个连接都创建一个线程,不用去维护多个线程。
- 避免了多线程之间的上下文切换导致的开销。
Selector 示意图和特点说明
说明如下:
Netty
的IO
线程NioEventLoop
聚合了Selector
(选择器,也叫多路复用器),可以同时并发处理成百上千个客户端连接。- 当线程从某客户端
Socket
通道进行读写数据时,若没有数据可用时,该线程可以进行其他任务。 - 线程通常将非阻塞
IO
的空闲时间用于在其他通道上执行IO
操作,所以单独的线程可以管理多个输入和输出通道。 - 由于读写操作都是非阻塞的,这就可以充分提升
IO
线程的运行效率,避免由于频繁I/O
阻塞导致的线程挂起。 - 一个
I/O
线程可以并发处理N
个客户端连接和读写操作,这从根本上解决了传统同步阻塞I/O
一连接一线程模型,架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。
Selector 类相关方法
注意事项
NIO
中的ServerSocketChannel
功能类似ServerSocket
、SocketChannel
功能类似Socket
。Selector
相关方法说明
selector.select();
//阻塞selector.select(1000);
//阻塞 1000 毫秒,在 1000 毫秒后返回selector.wakeup();
//唤醒 selectorselector.selectNow();
//不阻塞,立马返还
NIO 非阻塞网络编程原理分析图
NIO
非阻塞网络编程相关的(Selector
、SelectionKey
、ServerScoketChannel
和 SocketChannel
)关系梳理图
对上图的说明:
- 当客户端连接时,会通过
ServerSocketChannel
得到SocketChannel
。 Selector
进行监听select
方法,返回有事件发生的通道的个数。- 将
socketChannel
注册到Selector
上,register(Selector sel, int ops)
,一个Selector
上可以注册多个SocketChannel
。 - 注册后返回一个
SelectionKey
,会和该Selector
关联(集合)。 - 进一步得到各个
SelectionKey
(有事件发生)。 - 在通过
SelectionKey
反向获取SocketChannel
,方法channel()
。 - 可以通过得到的
channel
,完成业务处理。 - 直接看后面代码吧
NIO 非阻塞网络编程快速入门
案例:
- 编写一个
NIO
入门案例,实现服务器端和客户端之间的数据简单通讯(非阻塞) - 目的:理解
NIO
非阻塞网络编程机制
package com.qf.nio;import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;public class NIOServer {public static void main(String[] args) throws IOException {//新建服务的serverSocketServerSocketChannel serverSocketChannel = ServerSocketChannel.open();serverSocketChannel.socket().bind(new InetSocketAddress(6666));//设置serverSocketChannel为非阻塞的serverSocketChannel.configureBlocking(false);//新建selector注册Selector selector=Selector.open();//服务端socket注册到selector上面serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);//循环等待客户端的连接while (true){if (selector.select(1000)==0){System.out.println("服务器等待1秒,无连接");continue;}//获取相关的selectionKeys集合Set<SelectionKey> selectionKeys = selector.selectedKeys();Iterator<SelectionKey> iterator = selectionKeys.iterator();if (iterator.hasNext()){SelectionKey key = iterator.next();//如果改key是连接的状态if (key.isAcceptable()){SocketChannel socketChannel = serverSocketChannel.accept();System.out.println("客户端连接成功...."+socketChannel.hashCode());//非阻塞式socketChannel.configureBlocking(false);//把服务端的socketchanne注册到selector上面socketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));System.out.println("keys size:"+selector.keys().size());}//如果key是读取状态if (key.isReadable()){//读取socketchannel里面的数据SocketChannel channel = (SocketChannel) key.channel();ByteBuffer buffer = (ByteBuffer) key.attachment();channel.read(buffer);System.out.println("来自客户端的信息:"+new String(buffer.array()));}}//移除改selectoriterator.remove();}}
}
pos1:
1、对操作系统有一定了解的同学,就会大概知道这里监听的是一个Accept通道。这个通道的
作用就是监听,实际建立连接了还会有一个通道。
2、简单说一下为什么。因为客户端发请求的时候,服务器这边是肯定要先有一个监听通道,
监听某个端口是否有客户端要建立链接,如果有客户端想要建立链接,那么会再创建一个和
客户端真正通信的通道。
3、如果有其它客户端还想要建立链接,这个Accept监听端口监听到了,就会再创建几个真正
的通信通道。
4、也就是Server的一个端口可以建立多个TCP连接,因为IP层协议通过
目标地址+端口+源地址+源端口四个信息识别一个上下文
顺便插一句嘴:因为学netty的过程中,发现计算机网络和操作系统蛮重要的,所以接下来会写几篇这方面的文章
package com.qf.nio;import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;public class NioClient {public static void main(String[] args) throws IOException {//客户端的socketChannelSocketChannel socketChannel = SocketChannel.open();//设置为非阻塞socketChannel.configureBlocking(false);InetSocketAddress inetSocketAddress=new InetSocketAddress("127.0.0.1",6666);if (!socketChannel.connect(inetSocketAddress)){while (!socketChannel.finishConnect()){System.out.println("因为连接需要时间,客户端不会阻塞,可以做其他的工作");}}ByteBuffer byteBuffer=ByteBuffer.wrap("hello ,尚硅谷".getBytes());socketChannel.write(byteBuffer);//卡住System.in.read();}
}
实际执行效果可以复制代码去试下
SelectionKey
SelectionKey
,表示Selector
和网络通道的注册关系,共四种:
int OP_ACCEPT
:有新的网络连接可以accept
,值为16
int OP_CONNECT
:代表连接已经建立,值为8
int OP_READ
:代表读操作,值为1
int OP_WRITE
:代表写操作,值为4
源码中:
public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;
SelectionKey
相关方法
ServerSocketChannel
ServerSocketChannel
在服务器端监听新的客户端Socket
连接,负责监听,不负责实际的读写操作- 相关方法如下
SocketChannel
SocketChannel
,网络IO
通道,具体负责进行读写操作。NIO
把缓冲区的数据写入通道,或者把通道里的数据读到缓冲区。- 相关方法如下
NIO网络编程应用实例 - 群聊系统
实例要求:
- 编写一个
NIO
群聊系统,实现服务器端和客户端之间的数据简单通讯(非阻塞) - 实现多人群聊
- 服务器端:可以监测用户上线,离线,并实现消息转发功能
- 客户端:通过
Channel
可以无阻塞发送消息给其它所有用户,同时可以接受其它用户发送的消息(有服务器转发得到) - 目的:进一步理解
NIO
非阻塞网络编程机制 - 示意图分析和代码
代码:
package com.qf.group;import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
//服务端
public class GroupChatServer {public ServerSocketChannel serverSocketChannel;public Selector selector;public int port=6666;public GroupChatServer(){//新建serversocketchanneltry {serverSocketChannel=ServerSocketChannel.open();selector=Selector.open();//非阻塞serverSocketChannel.configureBlocking(false);serverSocketChannel.socket().bind(new InetSocketAddress(port));//注册到selector上面serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);}catch (IOException e){e.printStackTrace();}}public void listen(){try {while(true){int count=selector.select();if (count>0){//获取相关的selectionKeys集合Set<SelectionKey> selectionKeys = selector.selectedKeys();Iterator<SelectionKey> iterator = selectionKeys.iterator();if (iterator.hasNext()){SelectionKey key = iterator.next();if (key.isAcceptable()){//接收到的channelSystem.out.println("接受消息线程:"+Thread.currentThread().getName());SocketChannel socketChannel = serverSocketChannel.accept();//非阻塞式socketChannel.configureBlocking(false);//把服务端的socketchanne注册到selector上面socketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));//提示System.out.println(socketChannel.getRemoteAddress() + " 上线 ");}//假设是可读的状态if (key.isReadable()){//读取socketchannel里面的数据SocketChannel channel = (SocketChannel) key.channel();ByteBuffer buffer = (ByteBuffer) key.attachment();int read = channel.read(buffer);if (read>0){String msg = new String(buffer.array());System.out.println("来自客户端的信息:"+msg);readWrite(channel,msg);}}}iterator.remove();}else{System.out.println("服务器等待1秒,无连接");continue;}}}catch (IOException e){try {System.out.println(serverSocketChannel.getLocalAddress()+"已下线");} catch (IOException ioException) {ioException.printStackTrace();}}}private void readWrite(SocketChannel self, String msg) throws IOException {System.out.println("消息转发的线程:"+Thread.currentThread().getName());System.out.println("服务器转发消息中...");//遍历所有注册到 selector 上的 SocketChannel,并排除 selffor (SelectionKey key : selector.keys()) {//通过 key 取出对应的 SocketChannelChannel targetChannel = key.channel();//排除自己if (targetChannel instanceof SocketChannel && targetChannel != self) {//转型SocketChannel dest = (SocketChannel) targetChannel;//将 msg 存储到 bufferByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());//将 buffer 的数据写入通道dest.write(buffer);}}}public static void main(String[] args) {GroupChatServer groupChatServer=new GroupChatServer();groupChatServer.listen();}
}
package com.qf.group;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;
import java.util.Scanner;//客户端
public class GroupClient {public SocketChannel socketChannel;public Selector selector;public int port=6666;public String addr="127.0.0.1";public String userName;public GroupClient(){try {//新建socketServersocketChannel=SocketChannel.open(new InetSocketAddress(addr,port));socketChannel.configureBlocking(false);selector=Selector.open();socketChannel.register(selector, SelectionKey.OP_READ);userName=socketChannel.getLocalAddress().toString();}catch (IOException e){e.printStackTrace();}}public void read(){try {int readChannel = selector.select();if (readChannel>0){Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();if (iterator.hasNext()){SelectionKey key = iterator.next();if (key.isReadable()){SocketChannel socketChannel= (SocketChannel) key.channel();ByteBuffer buffer = ByteBuffer.allocate(1024);socketChannel.read(buffer);//读取byte里面的字符String msg = new String(buffer.array());System.out.println(msg.trim());}}iterator.remove();}}catch (Exception e){System.out.println("没有可用的通道");}}public void write(String msg){String info=userName+"说:"+msg;try {ByteBuffer byteBuffer=ByteBuffer.wrap(info.getBytes());socketChannel.write(byteBuffer);}catch (IOException e){e.printStackTrace();}}public static void main(String[] args) {GroupClient groupClient = new GroupClient();new Thread(){@Overridepublic void run() {while(true){groupClient.read();try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}}}.start();//在输入端输入数据Scanner scanner = new Scanner(System.in);while(scanner.hasNextLine()){String s = scanner.nextLine();groupClient.write(s);}}
}
NIO与零拷贝
1、尚硅谷这里的零拷贝感觉讲的感觉有点问题,但是为了笔记的完整性,任然保留了这里的笔记。不过笔者考虑再写一篇零拷贝。
2、而且这里课件的图也看不太清
3、读者可以将我写的零拷贝和尚硅谷这里讲的零拷贝对照着看,取长补短
零拷贝基本介绍
- 零拷贝是网络编程的关键,很多性能优化都离不开。
- 在
Java
程序中,常用的零拷贝有mmap
(内存映射)和sendFile
。那么,他们在OS
里,到底是怎么样的一个的设计?我们分析mmap
和sendFile
这两个零拷贝 - 另外我们看下
NIO
中如何使用零拷贝
传统 IO 数据读写
Java
传统 IO
和网络编程的一段代码
File file = new File("test.txt");
RandomAccessFile raf = new RandomAccessFile(file, "rw");byte[] arr = new byte[(int) file.length()];
raf.read(arr);Socket socket = new ServerSocket(8080).accept();
socket.getOutputStream().write(arr);
传统 IO 模型
DMA:direct memory access
直接内存拷贝(不使用 CPU
)
mmap 优化
mmap
通过内存映射,将文件映射到内核缓冲区,同时,用户空间可以共享内核空间的数据。这样,在进行网络传输时,就可以减少内核空间到用户空间的拷贝次数。如下图mmap
示意图
sendFile 优化
Linux2.1
版本提供了sendFile
函数,其基本原理如下:数据根本不经过用户态,直接从内核缓冲区进入到SocketBuffer
,同时,由于和用户态完全无关,就减少了一次上下文切换- 示意图和小结
- 提示:零拷贝从操作系统角度,是没有
cpu
拷贝 Linux在2.4
版本中,做了一些修改,避免了从内核缓冲区拷贝到Socketbuffer
的操作,直接拷贝到协议栈,从而再一次减少了数据拷贝。具体如下图和小结:
- 这里其实有一次
cpu
拷贝kernel buffer
->socket buffer
但是,拷贝的信息很少,比如lenght
、offset
消耗低,可以忽略
零拷贝的再次理解
- 我们说零拷贝,是从操作系统的角度来说的。因为内核缓冲区之间,没有数据是重复的(只有
kernel buffer
有一份数据)。 - 零拷贝不仅仅带来更少的数据复制,还能带来其他的性能优势,例如更少的上下文切换,更少的
CPU
缓存伪共享以及无CPU
校验和计算。
mmap 和 sendFile 的区别
mmap
适合小数据量读写,sendFile
适合大文件传输。mmap
需要4
次上下文切换,3
次数据拷贝;sendFile
需要3
次上下文切换,最少2
次数据拷贝。sendFile
可以利用DMA
方式,减少CPU
拷贝,mmap
则不能(必须从内核拷贝到Socket
缓冲区)。
NIO 零拷贝案例
案例要求:
- 使用传统的
IO
方法传递一个大文件 - 使用
NIO
零拷贝方式传递(transferTo
)一个大文件 - 看看两种传递方式耗时时间分别是多少
NewIOServer.javapackage com.atguigu.nio.zerocopy;import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;//服务器
public class NewIOServer {public static void main(String[] args) throws Exception {InetSocketAddress address = new InetSocketAddress(7001);ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();ServerSocket serverSocket = serverSocketChannel.socket();serverSocket.bind(address);//创建bufferByteBuffer byteBuffer = ByteBuffer.allocate(4096);while (true) {SocketChannel socketChannel = serverSocketChannel.accept();int readcount = 0;while (-1 != readcount) {try {readcount = socketChannel.read(byteBuffer);} catch (Exception ex) {// ex.printStackTrace();break;}//byteBuffer.rewind(); //倒带 position = 0 mark 作废}}}
}NewIOClient.javapackage com.atguigu.nio.zerocopy;import java.io.FileInputStream;
import java.net.InetSocketAddress;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;public class NewIOClient {public static void main(String[] args) throws Exception {SocketChannel socketChannel = SocketChannel.open();socketChannel.connect(new InetSocketAddress("localhost", 7001));String filename = "protoc-3.6.1-win32.zip";//得到一个文件channelFileChannel fileChannel = new FileInputStream(filename).getChannel();//准备发送long startTime = System.currentTimeMillis();//在 linux 下一个 transferTo 方法就可以完成传输//在 windows 下一次调用 transferTo 只能发送 8m, 就需要分段传输文件,而且要主要//传输时的位置=》课后思考...//transferTo 底层使用到零拷贝long transferCount = fileChannel.transferTo(0, fileChannel.size(), socketChannel);System.out.println("发送的总的字节数 = " + transferCount + " 耗时: " + (System.currentTimeMillis() - startTime));//关闭fileChannel.close();}
}
Java AIO 基本介绍
JDK7
引入了AsynchronousI/O
,即AIO
。在进行I/O
编程中,常用到两种模式:Reactor
和Proactor
。Java
的NIO
就是Reactor
,当有事件触发时,服务器端得到通知,进行相应的处理AIO
即NIO2.0
,叫做异步不阻塞的IO
。AIO
引入异步通道的概念,采用了Proactor
模式,简化了程序编写,有效的请求才启动线程,它的特点是先由操作系统完成后才通知服务端程序启动线程去处理,一般适用于连接数较多且连接时间较长的应用- 目前
AIO
还没有广泛应用,Netty
也是基于NIO
,而不是AIO
,因此我们就不详解AIO
了,有兴趣的同学可以参考《Java新一代网络编程模型AIO原理及Linux系统AIO介绍》
BIO、NIO、AIO 对比表
BIO | NIO | AIO | |
---|---|---|---|
IO模型 | 同步阻塞 | 同步非阻塞(多路复用) | 异步非阻塞 |
编程难度 | 简单 | 复杂 | 复杂 |
可靠性 | 差 | 好 | 好 |
吞吐量 | 低 | 高 | 高 |
举例说明
- 同步阻塞:到理发店理发,就一直等理发师,直到轮到自己理发。
- 同步非阻塞:到理发店理发,发现前面有其它人理发,给理发师说下,先干其他事情,一会过来看是否轮到自己.
- 异步非阻塞:给理发师打电话,让理发师上门服务,自己干其它事情,理发师自己来家给你理发
JAVA【Netty】第一讲相关推荐
- Java基础第一讲:Java的故事和Java编程环境搭建
{ Android学习指南 } 适于自学的ANDORID学习指南,基于ANDROID 2.2.2.3.3及3.0版本讲解 <ANDROID学习指南>目录 RSS Java基础第一讲:Jav ...
- Java数据结构第一讲-排序算法
常见数据结构和算法实现(排序/查找/数组/链表/栈/队列/树/递归/海量数据处理/图/位图/Java版数据结构) 数据结构和算法作为程序员的基本功,一定得稳扎稳打的学习,我们常见的框架底层就是各类数据 ...
- 怎么理解面向对象编程【java基础第一讲】
面向对象编程(OOP)是什么 OOP:Object Oriented Programming.要讲面向对象我们先来理解一下面向过程的含义,如果你已经有c语言相关的开发经验可能就已经明白面向过程的意义. ...
- 《Effective Java》 第一讲:创建和销毁对象
前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家.点击跳转到教程. 一.用静态工厂方法代替构造器 用静态工厂的优点 : 1. 方法有名字,更好理解. 2.不必每次调用的 ...
- 【零基础】小声bb Java系列第一讲:Java简介与环境配置
其实发布在公众号这个平台上的技术文并不少,涵盖计算机领域的各个方向,Linux啊,算法啊,python啊等等,但我发现,很多文章都是需要读者具有一定的编码基础才可以理解.学习的,对于那些对计算机领域感 ...
- 《Effective Java》 第二讲:对于所有对象都通用的方法
前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家.点击跳转到教程. 上接<Effective Java> 第一讲:创建和销毁对象 八.覆盖 equals 时 ...
- java direct memory_第一讲 JVM内存四大类型:Heap,Stack,Contant,DirectMemory等
第一讲JVM内存四大类型:Heap,Stack,Contant,DirectMemory等 Stack属于栈的区域,属于每条线程私有的. 方法区和本地方法栈有很大的不同,方法区是用Java级别角度做的 ...
- 《第一阶段 Java基础 Day01笔记》————————第一讲 Java入门
第一讲 Java入门 1.爪哇岛(印尼) Java之父 ...
- C#发现之旅第一讲 C#-XML开发
C#发现之旅第一讲 C#-XML开发 袁永福 2008-5-15 系列课程说明 为了让大家更深入的了解和使用C#,我们将开始这一系列的主题为"C#发现之旅"的技术讲座.考虑 ...
- Stanford概率图模型: 第一讲 有向图-贝叶斯网络
原文链接(系列):http://blog.csdn.net/yangliuy/article/details/8067261 概率图模型(Probabilistic Graphical Model)系 ...
最新文章
- 送书 | 你一定能看懂的算法基础书(代码示例基于Python)
- C9---include,编译
- 通用算法-sql相似度模糊匹配
- hadoop jetty的应用
- JZOJ 4910. 【NOIP2017模拟12.3】子串
- java获取栈最大值_实现O(1)获取最大最小值的栈----java
- javascript学习-创建json对象数据,遍历
- Jacoco字节码植入原理(源码分析)
- 细数开源历史上的十个重大事件
- 【深度学习】TensorFlow之卷积神经网络
- 白话详解TCP的三次握手到底做了些什么!!!
- cc ai条码插件_科脉神秘黑科技产品横空出世,AI能为生鲜称重带来哪些变革?
- 达观杯文本分类——基于N-gram和LogisticRegression
- linux查看硬盘分区类型,linux 下查看硬盘分区类型
- android adb日志过滤包名,adb过滤只查看某一个app的日志
- Linux内核-CFS调度下带宽控制(Bandwidth Control)
- java一直显示载入中_java – 当类在包中时为GUI加载图像的问题
- matplotlib简单做图
- 吴恩达 02.改善深层神经网络:超参数调试、正则化以及优化 第一周作业
- “一文读懂”系列:AMS是如何动态管理进程的?
热门文章
- 有方科技N58与百度物联网核心套件的连接01
- python输入汉字的代码_基于python的汉字转GBK码实现代码
- Java学习资源整理
- 来给博客除草了:Learned Indexes for a Google-scale Disk-based Database
- 新春大促:买域名送解析,域名续费享优惠!
- 辛普森悖论 - 一个统计学上的悖论
- 故障模块名称: NetdiskExt64.dll的解决之法
- WinDBG 调试命令大全
- 使用opencv画框
- html通过id设置css样式,JavaScript修改style,id,class等css属性样式方法总结