java的nio_JAVA中的NIO(NewIO)

JAVA中的NIO

标准的IO是基于字节流和字符流进行操作的&＃xff0c;而JAVA中的NIO是基于Channel和Buffer进行操作的。

传统IO

graph TB;

字节流 --> InputStream;

字节流 --> OutputStream;

字符流 --> Reader;

字符流 --> Writer;

NIO

graph TB;

A[Channel] --> B[Buffer..];

C[Channel] --> D[Buffer..];

E[Channel] --> F[Buffer..];

核心模块

NIO主要有三个核心部分&＃xff1a;Selector、Channel、Buffer

数据总是从Channel读取到Buffer或者从Buffer写入到Channel中。

Selector可以监听多个Channel的多个事件。

graph TB;

Selector --> A[Channel];

Selector --> B[Channel];

Selector --> C[Channel];

A --> E1[Event...];

B --> E2[Event...];

C --> E3[Event...];

传统的IO与Channel的区别

1.传统的IO是BIO的&＃xff0c;而Channel是NIO的。

*当流调用了read()、write()方法后会一直阻塞线程直到数据被读取或写入完毕。

2.传统IO流是单向的&＃xff0c;而Channel是双向的。

Channel

FileChannel&＃xff1a;从文件中进行读取

DatagramChannel&＃xff1a;可以通过UDP协议在网络中进行数据的传输

SocketChannel&＃xff1a;可以通过TCP协议在网络中进行数据的传输

ServerSocketChannel&＃xff1a;可以作为一个服务器监听连接

Channel通用API:

read(buffer)&＃xff1a;将数据从Channel读取到Buffer中&＃xff0c;读取完毕返回-1。

read(buffer [])&＃xff1a;将数据从Channel读取到多个Buffer中&＃xff0c;仅当第一个Buffer被写满后往第二个Buffer中进行写入。

write(buffer)&＃xff1a;将Buffer中的数据写入到Channel中。

write(buffer[])&＃xff1a;将多个Buffer中的数据写入到Channel中&＃xff0c;仅当第一个Buffer中的数据被读取完毕后再从第二个Buffer中进行读取。

register(selector,interest)&＃xff1a;将Channel注册到Selector中&＃xff0c;同时需要向Selector传递要监听此Channel的事件类型(注册到Selector中的Channel一定要非阻塞的)

configureBlocking(boolean)&＃xff1a;设置Channel是否为阻塞。

transferFrom(position,count,channel)&＃xff1a;将其他Channel中的数据传输到当前Channel中。

transferTo(position,count,channel)&＃xff1a;将当前Channel中的数据传输到其他Channel中。

SocketChannel API

open()静态方法&＃xff1a;创建SocketChannel。

connect(new InetSocketAddress(port))方法&＃xff1a;连接服务器。

finishConnect()方法&＃xff1a;判断是否已经与服务器建立连接。

ServerSocketChannel API

open()静态方法&＃xff1a;创建ServerSocketChannel。

accept()方法&＃xff1a;该方法会一直阻塞线程直到有新连接到达。

阻塞式与非阻塞式Channel

正常情况下Channel都是阻塞的&＃xff0c;只有当调用了configureBlocking(false)方法时Channel才为非阻塞。

阻塞式Channel的connect()、accept()、read()、write()方法都会阻塞线程&＃xff0c;直到处理完毕。

非阻塞式Channel的connect()、accept()、read()、write()方法都是异步的。

*当调用了非阻塞式Channel的connect()方法后&＃xff0c;需要使用finishConnect()方法判断是否已经与服务器建立连接。

*当调用了非阻塞式Channel的accept()方法后&＃xff0c;需要根据方法的返回值是否为NULL判断是否接收到新的连接。

*当调用了非阻塞式Channel的read()方法后&＃xff0c;需要根据方法的返回值是否大于0判断是否有读取到数据。

*在使用非阻塞式Channel的write()方法时&＃xff0c;需要借助while循环与hasRemaining()方法保证buffer中的内容被全部写入。

*FileChannel一定是阻塞的。

示例

public void testFileChannel() throws IOException {

RandomAccessFile randomAccessFile &＃61; new RandomAccessFile(new File("F:\\笔记\\nginx.txt"), "rw");

FileChannel fileChannel &＃61; randomAccessFile.getChannel();

ByteBuffer byteBuffer &＃61; ByteBuffer.allocate(64);

int count &＃61; fileChannel.read(byteBuffer);

while (count !&＃61; -1) {

byteBuffer.flip();

System.out.println(new String(Arrays.copyOfRange(byteBuffer.array(),0,byteBuffer.limit()),Charset.forName("UTF-8")));

byteBuffer.clear();

count &＃61; fileChannel.read(byteBuffer);

}

}

Buffer

Buffer是一块可以进行读写操作的内存(顺序存储结构)

ByteBuffer&＃xff1a;基于Byte类型进行存储

CharBuffer&＃xff1a;基于Char类型进行存储

DoubleBuffer&＃xff1a;基于Double类型进行存储

FloatBuffer&＃xff1a;基于Float类型进行存储

IntBuffer&＃xff1a;基于Int类型进行存储

LongBuffer&＃xff1a;基于Long类型进行存储

ShortBuffer&＃xff1a;基于Short类型进行存储

Buffer的内部结构

1.capacity&＃xff1a;表示buffer的容量

2.position&＃xff1a;表示当前的位置(从0开始&＃xff0c;最大值为capacity-1)

3.limit&＃xff1a;在写模式中表示可以写入的个数(与capacity一样)&＃xff0c;在读模式中表示可以读取的个数。

从写模式转换成读模式

limit设置为position&＃43;1&＃xff0c;position设置为0。

从读模式转换成写模式

limit设置为capacity&＃xff0c;position设置为0。

往Buffer中写数据

1.将数据从Channel读取到Buffer中。

2.使用Buffer的put()方法。

从Buffer中读数据

1.将Buffer中的数据写入到Channel中。

2.使用Buffer的get()方法

Buffer通用API:

allocate(size)静态静态&＃xff1a;初始化一个Buffer。

flip()&＃xff1a;将buffer从写模式转换成读模式。

array()&＃xff1a;将Buffer中的内容转换成数组(不受limit控制)

get()&＃xff1a;获取Buffer中的内容。

hasRemaining()&＃xff1a;判断Buffer中是否还有未读的元素(limit - (postion&＃43;1) )

rewind()&＃xff1a;将positon设置为0。

clear()&＃xff1a;将limit设置为capacity&＃xff0c;position设置为0。

compact()&＃xff1a;将所有未读的元素移动到Buffer的起始处&＃xff0c;position指向最后一个未读的元素的下一位&＃xff0c;limit设置为capacity。

*clear()和compact()方法都可以理解成将Buffer从读模式转换成写模式&＃xff0c;区别在于compact()方法会保留未读取的元素。

mark()&＃xff1a;在当前position处打一个标记。

reset()&＃xff1a;将position恢复到标记处。

Selector

Selector用于监听多个Channel的多个事件(单线程)

graph TB;

Selector --> A[Channel];

Selector --> B[Channel];

Selector --> C[Channel];

A --> E1[connect];

B --> E2[accept];

C --> E3[connect];

C --> E4[read];

Channel的事件类型

1.连接就绪&＃xff1a;当SocketChannel、DatagramChannel成功与服务器建立连接时将会触发连接就绪事件。

2.接收就绪&＃xff1a;当有连接到达服务器时将会触发接收就绪事件。

3.读就绪&＃xff1a;当SocketChannel、DatagramChannel有数据可读时将会触发读就绪事件。

4.写就绪&＃xff1a;当SocketChannel、DatagramChannel可以进行数据写入时将会触发写就绪事件。

SelectionKey

SelectionKey用于存储Selector与Channel之间的相关信息。

SelectionKey中提供了四个常量分别代表Channel的事件类型。

SelectionKey.OP_CONNECT

SelectionKey.OP_ACCEPT

SelectionKey.OP_READ

SelectionKey.OP_WRITE

SelectableChannel提供的register(selector,interest)方法用于将Channel注册到Selector中&＃xff0c;同时需要向Selector传递要监听此Channel的事件类型&＃xff0c;当要监听的事件类型不止一个时可以使用或运算&＃xff0c;当将Channel注册到Selector后会返回SelectionKey实例&＃xff0c;用于存储Selector与此Channel之间的相关信息。

SelectionKey API&＃xff1a;

interestOps()方法&＃xff1a;返回Selector监听此Channel的事件类型。

readyOps()方法&＃xff1a;返回此Channel目前就绪的事件。

isAcceptable()&＃xff1a;判断Channel是否接收就绪。

isConnectable()&＃xff1a;判断Channel是否连接就绪。

isReadable()&＃xff1a;判断Channel是否读就绪。

isWriteable()&＃xff1a;判断Channel是否写就绪。

channel()&＃xff1a;返回具体的Channel实例。

selector()&＃xff1a;返回Selector实例。

attach()&＃xff1a;往SelectionKey中添加一个附加对象。

attachment()&＃xff1a;返回保存在SelectionKey中的附加对象。

Selector API&＃xff1a;

open()静态方法&＃xff1a;创建一个Selector。

select()方法&＃xff1a;该方法会一直阻塞线程直到所监听的Channel有事件就绪&＃xff0c;返回就绪的Channel个数(只会返回新就绪的Channel个数)

selectedKeys()方法&＃xff1a;返回就绪的Channel对应的SelectionKey。

*当Channel就绪的事件处理完毕后&＃xff0c;需要手动删除SelectionKey集合中该Channel对应的SelectionKey&＃xff0c;当该Channel再次有事件就绪时会自动加入到Selectionkey集合中。

非阻塞式Channel与Selector

非阻塞式Channel一般与Selector配合使用

当Selector监听到ServerSocketChannel接收就绪时&＃xff0c;那么此时可以立即调用ServerSocketChannel的accept()方法获取新连接。

当Selector监听到SocketChannel读就绪时&＃xff0c;那么此时可以立即调用SocketChannel的read()方法进行数据的读取。

非阻塞式服务器

/**

* &＃64;Author: Zhuang HaoTang

* &＃64;Date: 2019/10/26 16:35

* &＃64;Description:

*/

public class Server {

public void start() throws IOException {

Selector selector &＃61; Selector.open();

ServerSocketChannel serverSocketChannel &＃61; createNIOServerSocketChannel();

System.out.println("start nio server and bind port 8888");

serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

int ready &＃61; selector.select();

while (ready > 0) {

System.out.println("ready channel count " &＃43; ready);

Set selectionKeySet &＃61; selector.selectedKeys();

for (Iterator iterator &＃61; selectionKeySet.iterator(); iterator.hasNext(); ) {

SelectionKey selectionKey &＃61; iterator.next();

if (selectionKey.isAcceptable()) {

System.out.println("acceptable");

acceptHandler(selectionKey);

} else if (selectionKey.isReadable()) {

System.out.println("readable");

readHandler(selectionKey);

}

iterator.remove();

}

ready &＃61; selector.select();

}

}

private ServerSocketChannel createNIOServerSocketChannel() throws IOException {

ServerSocketChannel serverSocketChannel &＃61; ServerSocketChannel.open();

serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), 8888));

serverSocketChannel.configureBlocking(false);

return serverSocketChannel;

}

private void acceptHandler(SelectionKey selectionKey) throws IOException {

Selector selector &＃61; selectionKey.selector();

ServerSocketChannel serverSocketChannel &＃61; (ServerSocketChannel) selectionKey.channel();

SocketChannel socketChannel &＃61; serverSocketChannel.accept();

socketChannel.configureBlocking(false);

socketChannel.register(selector, SelectionKey.OP_READ);

System.out.println("accept client connection " &＃43; socketChannel.getLocalAddress());

}

private void readHandler(SelectionKey selectionKey) throws IOException {

SocketChannel socketChannel &＃61; (SocketChannel) selectionKey.channel();

ByteBuffer byteBuffer &＃61; ByteBuffer.allocate(100);

int num &＃61; socketChannel.read(byteBuffer);

if(num &＃61;&＃61; -1){ // 连接已断开

System.out.println("client "&＃43;socketChannel.getLocalAddress() &＃43; " disconnection");

socketChannel.close();

return;

}

byteBuffer.flip();

while (byteBuffer.hasRemaining()) {

byte b &＃61; byteBuffer.get();

System.out.println((char) b);

}

}

public static void main(String[] args) throws IOException {

Server server &＃61; new Server();

server.start();

}

}

*一个Channel不会同时有多个事件就绪&＃xff0c;以事件为单位。

*当客户端断开连接&＃xff0c;那么将会触发读就绪&＃xff0c;并且channel的read()方法返回-1&＃xff0c;表示连接已断开&＃xff0c;服务器应该要做出处理&＃xff0c;关闭这个连接。

客户端

/**

* &＃64;Auther: Zhuang HaoTang

* &＃64;Date: 2019/10/26 16:36

* &＃64;Description:

*/

public class Client {

public static void main(String[] args) throws IOException, InterruptedException {

SocketChannel socketChannel &＃61; SocketChannel.open();

socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(),8888));

String message &＃61; "today is sunday";

ByteBuffer byteBuffer &＃61; ByteBuffer.allocate(message.getBytes().length);

byteBuffer.put(message.getBytes());

byteBuffer.flip();

socketChannel.write(byteBuffer);

Thread.sleep(5000);

}

}

运行结果

Reactor模式

Reactor有三种模式

1.Reactor单线程模式

2.Reactor多线程模式

3.主从Reactor多线程模式

*Reactor模式是在NIO下实现的。

Reactor单线程模式

1.单线程的事件分化器&＃xff0c;同时这个线程需要处理接收、读、写就绪事件。

/**

* &＃64;Author: Zhuang HaoTang

* &＃64;Date: 2019/10/26 16:35

* &＃64;Description:

*/

public class ReactorSingleThreadServer {

private void start() throws IOException {

Selector selector &＃61; Selector.open();

ServerSocketChannel serverSocketChannel &＃61; createNIOServerSocketChannel();

System.out.println("start nio server and bind port 8888");

serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

int ready &＃61; selector.select();

while (ready > 0) {

System.out.println("ready channel count " &＃43; ready);

Set selectionKeySet &＃61; selector.selectedKeys();

for (Iterator iterator &＃61; selectionKeySet.iterator(); iterator.hasNext(); ) {

SelectionKey selectionKey &＃61; iterator.next();

if (selectionKey.isAcceptable()) {

System.out.println("acceptable");

acceptHandler(selectionKey);

} else if (selectionKey.isReadable()) {

System.out.println("readable");

readHandler(selectionKey);

}

iterator.remove();

}

ready &＃61; selector.select();

}

}

private ServerSocketChannel createNIOServerSocketChannel() throws IOException {

ServerSocketChannel serverSocketChannel &＃61; ServerSocketChannel.open();

serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), 8888));

serverSocketChannel.configureBlocking(false);

return serverSocketChannel;

}

private void acceptHandler(SelectionKey selectionKey) throws IOException {

Selector selector &＃61; selectionKey.selector();

ServerSocketChannel serverSocketChannel &＃61; (ServerSocketChannel) selectionKey.channel();

SocketChannel socketChannel &＃61; serverSocketChannel.accept();

socketChannel.configureBlocking(false);

socketChannel.register(selector, SelectionKey.OP_READ);

System.out.println("accept client connection " &＃43; socketChannel.getLocalAddress());

}

private void readHandler(SelectionKey selectionKey) throws IOException {

SocketChannel socketChannel &＃61; (SocketChannel) selectionKey.channel();

ByteBuffer byteBuffer &＃61; ByteBuffer.allocate(100);

int num &＃61; socketChannel.read(byteBuffer);

if (num &＃61;&＃61; -1) {

System.out.println("client " &＃43; socketChannel.getLocalAddress() &＃43; " disconnection");

socketChannel.close();

return;

}

byteBuffer.flip();

while (byteBuffer.hasRemaining()) {

byte b &＃61; byteBuffer.get();

System.out.println((char) b);

}

}

public static void main(String[] args) throws IOException {

ReactorSingleThreadServer server &＃61; new ReactorSingleThreadServer();

server.start();

}

}

Reactor多线程模式

1.单线程的事件分发器。

2.具体事件类型的Handler线程池(针对读写就绪事件)

3.业务线程池。

/**

* &＃64;Author: Zhuang HaoTang

* &＃64;Date: 2019-10-28 17:00

* &＃64;Description:

*/

public class ReactorMultiThreadServer {

private ThreadPoolExecutor eventHandlerPool &＃61; new ThreadPoolExecutor(10, 50, 2, TimeUnit.MINUTES, new ArrayBlockingQueue(200), new ThreadPoolExecutor.CallerRunsPolicy());

private void start() throws IOException {

Selector selector &＃61; Selector.open();

ServerSocketChannel serverSocketChannel &＃61; createNIOServerSocketChannel();

System.out.println("start nio server and bind port 8888");

serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

selector.select();

for (;;) {

Set selectionKeySet &＃61; selector.selectedKeys();

for (Iterator iterator &＃61; selectionKeySet.iterator(); iterator.hasNext(); ) {

final SelectionKey selectionKey &＃61; iterator.next();

if (selectionKey.isAcceptable()) {

System.out.println("acceptable");

acceptHandler(selectionKey); // 单线程同步处理接收就绪

} else if (selectionKey.isReadable()) {

System.out.println("readable");

eventHandlerPool.submit(new Runnable() {

&＃64;Override

public void run() {

readHandler(selectionKey);

}

});

}

iterator.remove();

}

selector.select();

}

}

private ServerSocketChannel createNIOServerSocketChannel() throws IOException {

ServerSocketChannel serverSocketChannel &＃61; ServerSocketChannel.open();

serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), 8888));

serverSocketChannel.configureBlocking(false);

return serverSocketChannel;

}

private void acceptHandler(SelectionKey selectionKey) throws IOException {

Selector selector &＃61; selectionKey.selector();

ServerSocketChannel serverSocketChannel &＃61; (ServerSocketChannel) selectionKey.channel();

SocketChannel socketChannel &＃61; serverSocketChannel.accept();

if (socketChannel !&＃61; null) {

socketChannel.configureBlocking(false);

socketChannel.register(selector, SelectionKey.OP_READ);

System.out.println("accept client connection " &＃43; socketChannel.getLocalAddress());

}

}

private void readHandler(SelectionKey selectionKey) {

SocketChannel socketChannel &＃61; (SocketChannel) selectionKey.channel();

ByteBuffer byteBuffer &＃61; ByteBuffer.allocate(100);

try {

int num &＃61; socketChannel.read(byteBuffer);

if (num &＃61;&＃61; -1) {

System.out.println("client " &＃43; socketChannel.getLocalAddress() &＃43; " disconnection");

socketChannel.close(); // 底层有些逻辑

return;

}

byteBuffer.flip();

while (byteBuffer.hasRemaining()) {

byte b &＃61; byteBuffer.get();

System.out.println((char) b);

}

} catch (Exception e) {

System.out.println("由于连接关闭导致并发线程读取异常");

}

}

public static void main(String[] args) throws IOException {

ReactorMultiThreadServer reactorServer &＃61; new ReactorMultiThreadServer();

reactorServer.start();

}

}

主从Reactor多线程模式

1.使用两个单线程的事件分发器。

第一个事件分发器只负责监听ServerSocketChannel的接收就绪事件&＃xff0c;同时ServerSocketChannel接收到的连接要注册到第二个事件分发器中。

第二个事件分发器只负责监听SocketChannel的读、写就绪事件。

2.具体事件类型的Handler线程池(针对读写就绪事件)

3.业务线程池。

/**

* &＃64;Author: Zhuang HaoTang

* &＃64;Date: 2019-10-28 17:00

* &＃64;Description:

*/

public class MainSubReactorMultiThreadServer {

private ThreadPoolExecutor eventHandlerPool &＃61; new ThreadPoolExecutor(10, 50, 2, TimeUnit.MINUTES, new ArrayBlockingQueue(200), new ThreadPoolExecutor.CallerRunsPolicy());

private void start() throws IOException {

final Selector mainSelector &＃61; Selector.open();

final Selector subSelector &＃61; Selector.open();

new Thread(new Runnable() {

&＃64;Override

public void run() {

try {

startMainSelector(mainSelector, subSelector);

} catch (IOException e) {

e.printStackTrace();

}

}

}).start();

new Thread(new Runnable() {

&＃64;Override

public void run() {

try {

startSubSelector(subSelector);

} catch (IOException e) {

e.printStackTrace();

}

}

}).start();

}

/**

* 第一个事件分发器,用于监听ServerSocketChannel的接收就绪事件

*/

private void startMainSelector(Selector mainSelector, final Selector subSelector) throws IOException {

ServerSocketChannel serverSocketChannel &＃61; createNIOServerSocketChannel();

System.out.println("start nio server and bind port 8888");

serverSocketChannel.register(mainSelector, SelectionKey.OP_ACCEPT);

mainSelector.select();

for (; ; ) {

Set selectionKeySet &＃61; mainSelector.selectedKeys();

SelectionKey selectionKey &＃61; Iterables.getOnlyElement(selectionKeySet);

if (selectionKey.isAcceptable()) {

System.out.println("acceptable");

acceptHandler(selectionKey, subSelector); // 单线程同步处理接收就绪

selectionKeySet.clear();

}

mainSelector.select();

}

}

/**

* 第二个事件分发器,用于监听SockChannel的读写就绪事件

*/

private void startSubSelector(Selector subSelector) throws IOException {

subSelector.select();

for (; ; ) {

Set selectionKeySet &＃61; subSelector.selectedKeys();

for (Iterator iterator &＃61; selectionKeySet.iterator(); iterator.hasNext(); ) {

final SelectionKey selectionKey &＃61; iterator.next();

if (selectionKey.isReadable()) {

System.out.println("readable");

eventHandlerPool.submit(new Runnable() {

&＃64;Override

public void run() {

readHandler(selectionKey);

}

});

iterator.remove();

}

}

subSelector.select();

}

}

private ServerSocketChannel createNIOServerSocketChannel() throws IOException {

ServerSocketChannel serverSocketChannel &＃61; ServerSocketChannel.open();

serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), 8888));

serverSocketChannel.configureBlocking(false);

return serverSocketChannel;

}

private void acceptHandler(SelectionKey selectionKey, Selector subSelector) throws IOException {

ServerSocketChannel serverSocketChannel &＃61; (ServerSocketChannel) selectionKey.channel();

SocketChannel socketChannel &＃61; serverSocketChannel.accept();

if (socketChannel !&＃61; null) {

socketChannel.configureBlocking(false);

subSelector.wakeup(); // 往Selector注册Channel时,Selector要处于非阻塞状态

socketChannel.register(subSelector, SelectionKey.OP_READ);

System.out.println("accept client connection " &＃43; socketChannel.getLocalAddress() &＃43; " and register to subSelector");

}

}

private void readHandler(SelectionKey selectionKey) {

SocketChannel socketChannel &＃61; (SocketChannel) selectionKey.channel();

ByteBuffer byteBuffer &＃61; ByteBuffer.allocate(100);

try {

int num &＃61; socketChannel.read(byteBuffer);

if (num &＃61;&＃61; -1) {

System.out.println("client " &＃43; socketChannel.getLocalAddress() &＃43; " disconnection");

socketChannel.close(); // 底层有些逻辑

return;

}

byteBuffer.flip();

while (byteBuffer.hasRemaining()) {

byte b &＃61; byteBuffer.get();

System.out.println((char) b);

}

} catch (Exception e) {

System.out.println("由于连接关闭导致并发线程读取异常");

}

}

public static void main(String[] args) throws IOException {

MainSubReactorMultiThreadServer reactorServer &＃61; new MainSubReactorMultiThreadServer();

reactorServer.start();

}

}

通用客户端

/**

* &＃64;Author: Zhuang HaoTang

* &＃64;Date: 2019/10/26 16:36

* &＃64;Description:

*/

public class Client {

public static void main(String[] args) throws IOException, InterruptedException {

SocketChannel socketChannel &＃61; SocketChannel.open();

socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(), 8888));

String message &＃61; "today is sunday";

ByteBuffer byteBuffer &＃61; ByteBuffer.allocate(message.getBytes().length);

byteBuffer.put(message.getBytes());

byteBuffer.flip();

socketChannel.write(byteBuffer);

Thread.sleep(5000);

ByteBuffer byteBuffer1 &＃61; ByteBuffer.allocate("wo".getBytes().length).put("wo".getBytes());

byteBuffer1.flip();

socketChannel.write(byteBuffer1);

ByteBuffer receiveBuffer &＃61; ByteBuffer.allocate(1024);

while (true) {

socketChannel.read(receiveBuffer);

receiveBuffer.flip();

while (receiveBuffer.hasRemaining()) {

System.out.println((char)receiveBuffer.get());

}

receiveBuffer.clear();

}

}

}

*主线程不需要等待具体事件类型的Handler处理完毕&＃xff0c;直接异步返回&＃xff0c;那么将会导致事件重复就绪&＃xff0c;程序做出相应的控制即可。

*当channel有数据可读时&＃xff0c;将会触发读就绪&＃xff0c;那么主线程将会不停的向线程池提交任务&＃xff0c;直到某个线程读取完毕&＃xff0c;此时将会停止读就绪&＃xff0c;其他线程读取到的个数为0。

*当客户端断开连接时&＃xff0c;将会触发读就绪&＃xff0c;那么主线程将会不停的向线程池提交任务&＃xff0c;直到某个线程关闭连接&＃xff0c;此时将会停止读就绪

一般不会直接去使用JAVA NIO&＃xff0c;只是通过JAVA NIO学习他的设计思想&＃xff0c;如果要想搭建NIO服务器那么应该使用Netty等NIO框架。

关于BIO和NIO的选择

BIO即同步并阻塞&＃xff0c;线程会进入阻塞状态&＃xff0c;如果并发连接数只有几百&＃xff0c;那么创建几百个线程去处理是没有任何问题的&＃xff0c;这种方式更加简单高效。

但是如果并发连接数达到几万&＃xff0c;那么显然创建几万个线程去处理是不可行的&＃xff0c;系统承受不了这个负荷&＃xff0c;此时应该使用NIO&＃xff0c;即同步非阻塞&＃xff0c;利用更少的线程去做更多的事情。

JAVA NIO就是使用NIO(同步非阻塞)&＃xff0c;使用IO多路复用的Select模型。

*不管客户端有多少个并发连接和请求&＃xff0c;服务端总是可以利用更少的线程去处理(单线程事件分发器 和 具体事件类型的Handler线程池)