【nio】nio非阻塞模式

已于 2023-02-02 22:04:32 修改
阅读量128 收藏
点赞数
分类专栏： nio 文章标签： nio
于 2023-01-30 21:04:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32088869/article/details/128808741
版权
一.服务端
1.耗能大
package com.learning.notblock;

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.List;

import static com.learning.bytebuffer.ByteBufferUtil.debugRead;

/**
 * @Author wangyouhui
 * @Description
 **/
@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {
        // 使用nio来理解阻塞模式
        // 0.ByteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(16);
        // 1.创建服务器
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 非阻塞模式
        serverSocketChannel.configureBlocking(false);
        // 2.绑定监听端口
        serverSocketChannel.bind(new InetSocketAddress(8080));

        // 3.连接集合
        List<SocketChannel> socketChannelList = new ArrayList<>();
        // 与多个客户端连接
        while(true){
            // 4.accept,建立与客户端的连接
//            log.info("connecting...");
            // 非阻塞，线程还会继续运行；如果没有连接建立，socketChannel返回的是null
            SocketChannel socketChannel = serverSocketChannel.accept();
            if(socketChannel != null){
                log.info("connected...{}", socketChannel);
                // 将socketChannel设置为非阻塞模式
                socketChannel.configureBlocking(false);
                socketChannelList.add(socketChannel);
            }
            for(SocketChannel channel : socketChannelList){
                // 5.接收客户端发送的数据
//                log.info("before read...{}", channel);
                // 非阻塞，线程仍然会继续运行。如果没有读到数据，read方法返回0
                int read = channel.read(byteBuffer);
                if(read > 0){
                    // 切换到读模式
                    byteBuffer.flip();
                    debugRead(byteBuffer);
                    byteBuffer.clear();
                    log.debug("after read...{}", channel);
                }
            }
        }
    }
}
2.selector处理accept
package com.learning.notblock;

import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.*;
import java.util.Iterator;

/**
 * @Author wangyouhui
 * @Description
 **/
@Slf4j
public class SelectorServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个selector,管理多个channel
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);

        // 2. 建立selector和channel的联系（注册）
        // SelectionKey的作用：将来事件发生后，通过它可以知道和哪个channel的事件
        SelectionKey serverSocketChannelSelectionKey = serverSocketChannel.register(selector, 0, null);
        log.info("register key:{}", serverSocketChannelSelectionKey);

        // 四种事件类型
        /*
         * accept: 会在有连接请求时触发
         * connect: 是客户端，连接建立后触发
         * read: 可读事件
         * write: 可写事件
         */
        // key只关注accept事件
        serverSocketChannelSelectionKey.interestOps(SelectionKey.OP_ACCEPT);

        serverSocketChannel.bind(new InetSocketAddress(8080));
        while(true){
            // 3. select 方法，没有事件发生，则线程阻塞；有事件发生，线程才恢复运行
            selector.select();
            // 4. 处理事件, selectedKeys 内部包含了所有发生的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                log.info("key:{}", key);
                ServerSocketChannel channel = (ServerSocketChannel)key.channel();
                SocketChannel socketChannel = channel.accept();
                log.info("{}", socketChannel);
            }
        }
    }
}
3.selector处理cancel
package com.learning.notblock;

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.*;
import java.util.Iterator;

/**
 * @Author wangyouhui
 * @Description
 **/
@Slf4j
public class SelectorServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个selector,管理多个channel
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);

        // 2. 建立selector和channel的联系（注册）
        // SelectionKey的作用：将来事件发生后，通过它可以知道和哪个channel的事件
        SelectionKey serverSocketChannelSelectionKey = serverSocketChannel.register(selector, 0, null);
        log.info("register key:{}", serverSocketChannelSelectionKey);

        // 四种事件类型
        /*
         * accept: 会在有连接请求时触发
         * connect: 是客户端，连接建立后触发
         * read: 可读事件
         * write: 可写事件
         */
        // key只关注accept事件
        serverSocketChannelSelectionKey.interestOps(SelectionKey.OP_ACCEPT);

        serverSocketChannel.bind(new InetSocketAddress(8080));
        while(true){
            // 3. select 方法，没有事件发生，则线程阻塞；有事件发生，线程才恢复运行
            // 注意：select在事件未处理时，它不会阻塞
            selector.select();
            // 4. 处理事件, selectedKeys 内部包含了所有发生的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                log.info("key:{}", key);
//                ServerSocketChannel channel = (ServerSocketChannel)key.channel();
//                SocketChannel socketChannel = channel.accept();
//                log.info("{}", socketChannel);
                key.cancel();
            }
        }
    }
}
3.客户端正常或异常关闭
package com.learning.notblock;

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

import static com.learning.bytebuffer.ByteBufferUtil.debugRead;

/**
 * @Author wangyouhui
 * @Description
 **/
@Slf4j
public class SelectorServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个selector,管理多个channel
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);

        // 2. 建立selector和channel的联系（注册）
        // SelectionKey的作用：将来事件发生后，通过它可以知道和哪个channel的事件
        SelectionKey serverSocketChannelSelectionKey = serverSocketChannel.register(selector, 0, null);
        log.info("register key:{}", serverSocketChannelSelectionKey);

        // 四种事件类型
        /*
         * accept: 会在有连接请求时触发
         * connect: 是客户端，连接建立后触发
         * read: 可读事件
         * write: 可写事件
         */
        // key只关注accept事件
        serverSocketChannelSelectionKey.interestOps(SelectionKey.OP_ACCEPT);

        serverSocketChannel.bind(new InetSocketAddress(8080));
        while(true){
            // 3. select 方法，没有事件发生，则线程阻塞；有事件发生，线程才恢复运行
            // 注意：select在事件未处理时，它不会阻塞
            selector.select();
            // 4. 处理事件, selectedKeys 内部包含了所有发生的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                // 处理key时要从selectedKeys集合中删除，否则下次处理时会出错。例如channel.accept(),没有连接的时候为null，socketChannel.configureBlocking(false);会报空指针
                iterator.remove();
                log.info("key:{}", key);
                // 5.区分事件类型
                if (key.isAcceptable()) {
                    // 如果是accept
                    ServerSocketChannel channel = (ServerSocketChannel)key.channel();
                    SocketChannel socketChannel = channel.accept();
                    socketChannel.configureBlocking(false);
                    SelectionKey socketChannelSelectionKey = socketChannel.register(selector,0, null);
                    socketChannelSelectionKey.interestOps(SelectionKey.OP_READ);
                    log.info("{}", socketChannel);
                } else if(key.isReadable()){
                    // 如果是read
                    // 拿到触发事件的channel
                    try {
                        SocketChannel channel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(16);
                        // 如果是正常断开，read方法返回值是-1
                        int read = channel.read(buffer);
                        if(read == -1){
                            key.cancel();
                        }else{
                            buffer.flip();
                            debugRead(buffer);
                        }
                    }catch(IOException e){
                        e.printStackTrace();
                        // 客户端断开了，需要将key取消（从selector的keys集合中整正删除key)
                        key.cancel();
                    }
                }
            }
        }
    }
}
4.消息边界超出扩容模式
package com.learning.notblock;

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

import static com.learning.bytebuffer.ByteBufferUtil.debugAll;

/**
 * @Author wangyouhui
 * @Description
 **/
@Slf4j
public class SelectorServer {
    private static void split(ByteBuffer source) {
        // 切换为读模式
        source.flip();
        for(int i=0;i<source.limit();i++){
            // 找到一条完整消息
            if (source.get(i)=='\n') {
                int length = i + 1 -source.position();
                // 把这条完整消息存入新的ByteBuffer
                ByteBuffer target = ByteBuffer.allocate(length);
                // 从source读，向target写
                for(int j=0;j<length;j++){
                    target.put(source.get());
                }
                debugAll(target);
            }
        }
        // 从上次未读的位置读
        source.compact();
    }

    public static void main(String[] args) throws IOException {
        // 1. 创建一个selector,管理多个channel
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);

        // 2. 建立selector和channel的联系（注册）
        // SelectionKey的作用：将来事件发生后，通过它可以知道和哪个channel的事件
        SelectionKey serverSocketChannelSelectionKey = serverSocketChannel.register(selector, 0, null);
        log.info("register key:{}", serverSocketChannelSelectionKey);

        // 四种事件类型
        /*
         * accept: 会在有连接请求时触发
         * connect: 是客户端，连接建立后触发
         * read: 可读事件
         * write: 可写事件
         */
        // key只关注accept事件
        serverSocketChannelSelectionKey.interestOps(SelectionKey.OP_ACCEPT);

        serverSocketChannel.bind(new InetSocketAddress(8080));
        while(true){
            // 3. select 方法，没有事件发生，则线程阻塞；有事件发生，线程才恢复运行
            // 注意：select在事件未处理时，它不会阻塞
            selector.select();
            // 4. 处理事件, selectedKeys 内部包含了所有发生的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                // 处理key时要从selectedKeys集合中删除，否则下次处理时会出错。例如channel.accept(),没有连接的时候为null，socketChannel.configureBlocking(false);会报空指针
                iterator.remove();
                log.info("key:{}", key);
                // 5.区分事件类型
                if (key.isAcceptable()) {
                    // 如果是accept
                    ServerSocketChannel channel = (ServerSocketChannel)key.channel();
                    SocketChannel socketChannel = channel.accept();
                    socketChannel.configureBlocking(false);
                    ByteBuffer buffer = ByteBuffer.allocate(16);
                    // 将一个byteBuffer作为附件关联到selectionKey上
                    SelectionKey socketChannelSelectionKey = socketChannel.register(selector,0, buffer);
                    socketChannelSelectionKey.interestOps(SelectionKey.OP_READ);
                    log.info("{}", socketChannel);
                } else if(key.isReadable()){
                    // 如果是read
                    // 拿到触发事件的channel
                    try {
                        SocketChannel channel = (SocketChannel) key.channel();
//                        ByteBuffer buffer = ByteBuffer.allocate(16);
                        // 获取selectionKey上关联的附件
                        ByteBuffer buffer = (ByteBuffer) key.attachment();
                        // 如果是正常断开，read方法返回值是-1
                        int read = channel.read(buffer);
                        if(read == -1){
                            key.cancel();
                        }else{
                            split(buffer);
                            if(buffer.position() == buffer.limit()) {
                                ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity() * 2);
                                buffer.flip();
                                newBuffer.put(buffer);
                                key.attach(newBuffer);
                            }
                        }
                    }catch(IOException e){
                        e.printStackTrace();
                        // 客户端断开了，需要将key取消（从selector的keys集合中整正删除key)
                        key.cancel();
                    }
                }
            }
        }
    }
}
二.客户端
package com.learning.notblock;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;

/**
 * @Author wangyouhui
 * @Description TODO
 **/
public class Client {
    public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open();
        sc.connect(new InetSocketAddress("localhost", 8080));
        System.out.println("waiting...");
    }
}
王佑辉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java-NIO非阻塞服务器示例.docx
11-15
本资源主要讲解了Java-NIO非阻塞服务器的示例，通过使用Java-NIO包来实现非阻塞的服务器端模式。下面是从代码中提取的知识点： 一、Java-NIO包简介 Java-NIO（New I/O）包是Java 1.4版本中引入的新IO处理机制，...
Nio非阻塞socket通信demo
05-10
在这个“Nio非阻塞socket通信demo”中，我们可以深入理解NIO在Socket通信中的应用。 1. **Java NIO基础** - **通道（Channels）**：NIO的核心概念之一，通道是数据读写的目标或来源，如文件通道、套接字通道等。...
【JAVA基础】- 同步非阻塞模式NIO详解
记录总结工作过往
08-11 2964
同步非阻塞的特点：应用程序的线程需要不断的进行IO系统调用，轮询数据是否已经准备好，如果没有准备好，就继续轮询，直到完成IO系统调用为止。同步非阻塞IO的特点：每次发起的IO系统调用，在内核等待数据过程中可以立即返回。用户线程不会被阻塞，实时性较好。不断地轮询内核，这将占用大量的CPU时间，效率低下。总体来说，在高并发应用场景下，同步非阻塞IO也是不可用的。一般Web服务器不适用这种IO模型。这种IO模型一般很少直接使用，而是在其他IO模型中使用非阻塞IO这一特性。
【转载】Java NIO系列教程（十）非阻塞式服务器
nukix
11-16 275
即使你知道Java NIO 非阻塞的工作特性（如Selector,Channel,Buffer等组件），但是想要设计一个非阻塞的服务器仍然是一件很困难的事。非阻塞式服务器相较于阻塞式来说要多上许多挑战。本文将会讨论非阻塞式服务器的主要几个难题，并针对这些难题给出一些可能的解决方案。查找关于非阻塞式服务器设计方面的资料实在不太容易，所以本文提供的解决方案都是基于本人工作和想法上的。如果各位有其他的替代方案或者更好的想法，我会很乐意听取这些方案和想法！
NIO阻塞模式和非阻塞模式的处理
热门推荐
大佛拈花的博客
06-21 1万+
文章目录一、NIO阻塞服务端客户端代码二、NIO非阻塞设置三、ServerSocketChannel四、NIO Selector处理accept1、Selector的创建2、服务端3、客户端4、取消事件5、处理read事件5.1、处理空指针异常5.2、IO异常 一、NIO阻塞服务端 下面演示的代码是单线程处理服务端的连接，以及读取数据。 import java.io.IOException; import java.net.InetSocketAddress; import java.nio.Buffer
解读NIO Socket非阻塞模式
SimplyJava的专栏
10-26 725
解读NIO Socket非阻塞模式
java NIO(三)之阻塞与非阻塞
I can @ me
05-31 6948
                                                      阻塞与非阻塞阻塞   传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write()时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行 IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程...
java解读NIOSocket非阻塞模式.zip
09-02
jdk供的无阻塞I/O（NIO）有效解决了多线程服务器存在的线程开销问题，但在使用上略显得复杂一些。在NIO中使用多线程，主要目的已不是为了应对每个客户端请求而分配独立的服务...非阻塞的NIO有何神秘之处？直接上代码！
java NIO详细教程
10-09
// 设置非阻塞模式 serverSocketChannel.configureBlocking(false); // 注册到Selector serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); // 循环监听事件 while (true) { if (selector.select...
基于JavaNIO的非阻塞通信的研究与实现
12-22
- Java NIO的非阻塞模式主要依赖于选择器和通道的概念。选择器可以监听一个或多个通道上的事件，当某个通道上的事件发生时，选择器会通知应用程序，应用程序就可以对该事件做出响应。 - **事件处理** - 通过选择器...
五、NIO 的非阻塞式网络通信
这天有点热的博客
05-27 134
一、普通IO 传统的IO当客户端请求服务端的资源，这个时候不确定是否准备好资源。如果这个时候存在问题，当前线程则会一直等待，不能再处理其他问题。就造成了阻塞。 二、NIO NIO新增了选择器，所有的通道都会注册到选择器上，由选择器进行监控。当选择器监控到，客户端请求的资源都准备好的时候，再调用服务端的一个或多个线程，从而提高线程的利用率。 阻塞式： package com.stu.nio; import org.junit.Test; import java.io.IOException;
NIO阻塞与非阻塞式
张不帅
12-24 1459
NIO的非阻塞模式 NIO完成核心的东西是一个选择器,Selector,选择器主要是将每一个传输数据的通道注册到选择器上,选择器作用是监控这些IO的状态(读,写,连接状态),然后用选择器监控通道的状况,等待所有的线程准备就绪时,选择器将任务分配到服务端一个或者多个线程上再去运行 NIO完成网络通信的三个核心 1.通道(Channel):负责连接 java.nio.channels.Channel ...
【Java.NIO】Java NIO中的阻塞 V.S. 非阻塞
王晓斌的专栏
12-07 2485
从JDK1.4版本开始，引入了非阻塞的通信机制。 服务器程序接受客户连接，客户程序建立与服务器的连接，以及服务器程序和客户端程序收发数据的操作都可以按非阻塞的方式进行。服务器程序只需要创建一个线程，就能完成同时与多个客户通信的任务。 线程阻塞 线程在运行中会因为某些原因而阻塞，所有处于阻塞状态的线程的共同特征是： 放弃CPU，暂停运行，只有等到导致阻塞的原因消除，才能恢复运行；或者
java nio 非阻塞_JavaNIO非阻塞模式
weixin_42400074的博客
02-13 205
package com.java.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.cha...
NIO的非阻塞式实现
qq_41184055的博客
08-13 1885
首先解释一下阻塞和非阻塞 对于传统的BIO，线程在同一时间只能等待数据的发送和接收，在此期间不能做其他的事 用图来表示 所以对于这种io，我们应该使用多线程的方式完成io通信 多线程虽然能完成同时接收和发送，但是本质上也是多个阻塞的单线程，多个线程中某个陷入阻塞，该线程还是不能做其他的事，造成资源的浪费。 NIO非阻塞模式，将每一个用于传输数据的通道都注册到选择器上，选择器监控通道的io状况...
NIO——非阻塞式网络通信
笔记别偷看
05-21 601
阻塞与非阻塞 传统的IO 流都是阻塞式的。也就是说，当一个线程调用read() 或write() 时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。 Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞IO 的空闲时间用于在其他通道上执行IO 操作，所以
Java的非阻塞模式(NIO)
code_leader的博客
04-19 226
java非阻塞模式简易实现 客户端 @Test public void client() throws IOException { //创建一个通道(客户端) SocketChannel channel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898)); //切换成非阻塞模式 channel.configureBlocking(false); //分配制
Netty4自学笔记 (3) - Netty NIO Server和Client 样例说明
最新发布
CoderCoding的博客
08-03 958
更新节奏缓慢，因为每晚学习注意力不够集中，学习进展缓慢。本还给自己找了一大堆其他理由，但摸着良心问自己，似乎只有这个理由说的通。
Java NIO入门：非阻塞IO详解与实战
非阻塞模式意味着当数据未准备好时，I/O操作不会被阻塞，而是立即返回，允许线程执行其他任务。 在本教程中，学习者将深入理解NIO的各个方面，包括但不限于： 1. **基础概念**：介绍NIO库的基本原理和设计，帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王佑辉

老板，赏点吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值