NIO 非阻塞网络

已于 2022-09-10 18:07:19 修改
阅读量64 收藏
点赞数
文章标签： 网络 nio 服务器
于 2022-09-10 15:25:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56506584/article/details/126796747
版权

客户端连接

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 Exception{

        //创建ServerSocketChannel -> ServerSocket

        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //得到一个Selecor对象
        Selector selector = Selector.open();

        //绑定一个端口6666, 在服务器端监听
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        //设置为非阻塞
        serverSocketChannel.configureBlocking(false);

        //把 serverSocketChannel 注册到  selector 关心 事件为 OP_ACCEPT       pos_1
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("注册后的selectionkey 数量=" + selector.keys().size()); // 1



        //循环等待客户端连接
        while (true) {

            //这里我们等待1秒，如果没有事件发生, 返回
            if(selector.select(1000) == 0) { //没有事件发生
                System.out.println("服务器等待了1秒，无连接");
                continue;
            }

            //如果返回的>0, 就获取到相关的 selectionKey集合
            //1.如果返回的>0， 表示已经获取到关注的事件
            //2. selector.selectedKeys() 返回关注事件的集合
            //   通过 selectionKeys 反向获取通道
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            System.out.println("selectionKeys 数量 = " + selectionKeys.size());

            //遍历 Set<SelectionKey>, 使用迭代器遍历
            Iterator<SelectionKey> keyIterator = selectionKeys.iterator();

            while (keyIterator.hasNext()) {
                //获取到SelectionKey
                SelectionKey key = keyIterator.next();
                //根据key 对应的通道发生的事件做相应处理
                if(key.isAcceptable()) { //如果是 OP_ACCEPT, 有新的客户端连接
                    //该该客户端生成一个 SocketChannel
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("客户端连接成功 生成了一个 socketChannel " + socketChannel.hashCode());
                    //将  SocketChannel 设置为非阻塞
                    socketChannel.configureBlocking(false);
                    //将socketChannel 注册到selector, 关注事件为 OP_READ， 同时给socketChannel
                    //关联一个Buffer
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));

                    System.out.println("客户端连接后 ，注册的selectionkey 数量=" + selector.keys().size()); //2,3,4..


                }
                if(key.isReadable()) {  //发生 OP_READ

                    //通过key 反向获取到对应channel
                    SocketChannel channel = (SocketChannel)key.channel();

                    //获取到该channel关联的buffer
                    ByteBuffer buffer = (ByteBuffer)key.attachment();
                    channel.read(buffer);
                    System.out.println("form 客户端 " + new String(buffer.array()));

                }

                //手动从集合中移动当前的selectionKey, 防止重复操作
                keyIterator.remove();

            }

        }

    }
}

服务端连接

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NIOClient {
    public static void main(String[] args) throws Exception{

        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器端的ip 和 端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {

            while (!socketChannel.finishConnect()) {
                System.out.println("因为连接需要时间，客户端不会阻塞，可以做其它工作..");
            }
        }

        //...如果连接成功，就发送数据
        String str = "hello, 123456~";
        //Wraps a byte array into a buffer
        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
        //发送数据，将 buffer 数据写入 channel
        socketChannel.write(buffer);
        System.in.read();

    }
}

本地群聊天


// 服务端：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class GroupChatServer {

    //定义属性
    private Selector selector;
    private ServerSocketChannel listenChannel;

    private static final int PORT = 6667;

    //构造器
    //初始化工作
    public GroupChatServer() {
        try {
            //得到选择器
            selector = Selector.open();
            //ServerSocketChannel
            listenChannel = ServerSocketChannel.open();
            //绑定端口
            listenChannel.socket().bind(new InetSocketAddress(PORT));
            //设置非阻塞模式
            listenChannel.configureBlocking(false);
            //将该 listenChannel 注册到 selector
            listenChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void listen() {
        try {
            //循环处理
            while (true) {
                int count = selector.select();
                if (count > 0) { //有事件处理
                    // 遍历得到 selectionKey 集合
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        //取出 selectionkey
                        SelectionKey key = iterator.next();
                        //监听到 accept
                        if (key.isAcceptable()) {
                            SocketChannel sc = listenChannel.accept();
                            sc.configureBlocking(false);
                            //将该 sc 注册到 seletor
                            sc.register(selector, SelectionKey.OP_READ);
                            //提示
                            System.out.println(sc.getRemoteAddress() + " 上线 ");
                        }
                        if (key.isReadable()) {//通道发送read事件，即通道是可读的状态
                            // 处理读(专门写方法..)
                            readData(key);
                        }
                        //当前的 key 删除，防止重复处理
                        iterator.remove();
                    }
                } else {
                    System.out.println("等待....");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //发生异常处理....
        }
    }

    //读取客户端消息
    public void readData(SelectionKey key) {
        SocketChannel channel = null;
        try {
            //得到 channel
            channel = (SocketChannel) key.channel();
            //创建 buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int count = channel.read(buffer);
            //根据 count 的值做处理
            if (count > 0) {
                //把缓存区的数据转成字符串
                String msg = new String(buffer.array());
                //输出该消息
                System.out.println("form客户端:" + msg);
                //向其它的客户端转发消息(去掉自己),专门写一个方法来处理
                sendInfoToOtherClients(msg, channel);
            }
        } catch (IOException e) {
            try {
                System.out.println(channel.getRemoteAddress() + "离线了..");
                //取消注册
                key.cancel();
                //关闭通道
                channel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }
    }

    //转发消息给其它客户(通道)
    private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {

        System.out.println("服务器转发消息中...");
        //遍历所有注册到 selector 上的 SocketChannel,并排除 self
        for (SelectionKey key : selector.keys()) {
            //通过 key 取出对应的 SocketChannel
            Channel targetChannel = key.channel();
            //排除自己
            if (targetChannel instanceof SocketChannel && targetChannel != self) {
                //转型
                SocketChannel dest = (SocketChannel) targetChannel;
                //将 msg 存储到 buffer
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                //将 buffer 的数据写入通道
                dest.write(buffer);
            }
        }
    }

    public static void main(String[] args) {
        //创建服务器对象
        GroupChatServer groupChatServer = new GroupChatServer();
        groupChatServer.listen();
    }
}

// 客户端：

package com.atguigu.nio.groupchat;

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 GroupChatClient {

    //定义相关的属性
    private final String HOST = "127.0.0.1";//服务器的ip
    private final int PORT = 6667;//服务器端口
    private Selector selector;
    private SocketChannel socketChannel;
    private String username;

    //构造器,完成初始化工作
    public GroupChatClient() throws IOException {
        
        selector = Selector.open();
        //连接服务器
        socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //将 channel 注册到selector
        socketChannel.register(selector, SelectionKey.OP_READ);
        //得到 username
        username = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println(username + " is ok...");
    }

    //向服务器发送消息
    public void sendInfo(String info) {
        info = username + " 说：" + info;
        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //读取从服务器端回复的消息
    public void readInfo() {
        try {
            int readChannels = selector.select();
            if (readChannels > 0) {//有可以用的通道
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        //得到相关的通道
                        SocketChannel sc = (SocketChannel) key.channel();
                        //得到一个 Buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        //读取
                        sc.read(buffer);
                        //把读到的缓冲区的数据转成字符串
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                }
                iterator.remove(); //删除当前的 selectionKey,防止重复操作
            } else {
                //System.out.println("没有可以用的通道...");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

        //启动我们客户端
        GroupChatClient chatClient = new GroupChatClient();
        //启动一个线程,每个 3 秒，读取从服务器发送数据
        new Thread() {
            public void run() {
                while (true) {
                    chatClient.readInfo();
                    try {
                        Thread.currentThread().sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        //发送数据给服务器端
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            chatClient.sendInfo(s);
        }
    }
}
好人好报i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
非阻塞socket设置方法
leiting_imecas的博客
05-05 910
(1)阻塞block    所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回。    例如socket编程中connect、accept、recv、recvfrom这样的阻塞程序。    再如绝大多数的函数调用、语句执行，严格来说，他们都是以阻塞方式执行的。 (2)非阻塞non-block  
非阻塞式网络服务器 nio.pdf recator
04-30
如何从菜鸟变高手，青蛙变王子，灰姑娘变公主？赶紧下载，非同一般。 有下载好的，请推荐同类书籍。南无阿弥陀佛！
四.NIO网络编程原理分析
liangzai888的博客
03-08 142
NIO网络编程关系梳理图 NIO 非阻塞网络编程相关的(Selector、SelectionKey、ServerScoketChannel和SocketChannel) 关系梳理图 当客户端连接时，会通过ServerSocketChannel 得到 SocketChannel Selector 进行监听 select 方法, 返回有事件发生的通道的个数. 将socketChannel注册到Selector上, register(Selector sel, int ops), 一个selector上可以注
Java简单实现Socket非阻塞通信
weixin_30423977的博客
03-01 1088
用java实现socket C/S通信很简单，很多教科书上都有。但是这些通信模型大都是阻塞式的，其弊端也很明显：一方必须要接收的到对方的消息后，才能编辑自己的消息发出。同样对方也要一直等待这条消息收到后才能发送新的消息。用网络通信的知识讲，大概就是半双工通信吧。这就好比聊天的时候，两个人只能一人一句的聊天。不能一个人连着发送多句话。 而要实现非阻塞通信呢，...
java非阻塞socket_Java NIO 非阻塞Socket服务器构建
weixin_39747615的博客
02-18 238
推荐阅读IBMdeveloperWorks中NIO的入门教程，尤其是对块I/O和流I/O不太清楚的开发者。说到socket服务器，第一反应是java.net.Socket这个类。事实上在并发和响应时间要求不高的场合，是可以用java.net.Socket来实现的，比如写一个局域网聊天工具、发送文件等。但它的缺点也很明显，需要自行对接受的线程进行维护，管理缓冲区的分配等，我尝试过用java.net...
阻塞和非阻塞网络、异步和非异步网络区别点
qq_41979948的博客
03-21 823
阻塞和非阻塞主要区别在于是否等待对方响应，而异步和非异步主要区别在于回调操作的方式。在实际的网络编程中，我们需要根据具体的需求选择合适的方式来进行开发，以满足程序的特定需求。
NIO思维导图学习资料
02-02
nio思维导图：适用于有一定编程基础的朋友，想系统学习NIO这块知识的朋友。知识点大体分3块：1:>概念了解(各类IO) 2>NIO的核心(缓存区，通道等) 3>网络IO
NIO概述
12-22
NIO非阻塞IO，运行当前程序在处理IO事务时，不会影响其他程序的运行，可以在不使用多线程的情况下，满足IO操作要求。 三大核心部分: 通道 Channel 文件操作，网络数据传递操作使用的通道 缓冲 Buffer...
nioreactor:无阻塞IOReact器
04-28
该项目的目标是在不使用外部依赖项的情况下探索Java非阻塞I / O功能，并提供可用于构建可扩展网络服务的精巧库。 多线程设计 由于React堆线程可以在执行IO时饱和，因此nioreactor使用接受器线程将新连接转发到可以在...
NIO-实践-多线程实例
09-28
NIO用于高性能Socket编程由来已久，网络也有较为丰富的原理和源代码。我这里主要介绍几点经验总结： 1.Selector.select()在筛选就绪的SelectionKey的时候，采用的是阻塞模式。同时只要在就绪的SelectionKey列表中有...
NIO模型
车车的博客
10-20 433
NIO的介绍 NIO(New IO)同步非阻塞IO模型，采用了事件驱动的思想来实现一个复用器，来解决大并发的问题 NIO中，将读、写、可连接、可接受等操作在BIO中是阻塞处理，将操作设置为非阻塞，并将这些操作视为事件，当关注某个事件时，将其注册到复用器Selector(本质上使用底层操作系统提供的IO复用器：select、poll，epoll)。由系统来监听事件是否准备就绪， 当socket有读或者可写操作时，系统会通知相应的用户程序来处理，将流读取到缓冲区或者写入到系统中 一个复用器上是...
什么还不懂Java NIO，看这一篇博客就够了！
JeremyIverson的博客
09-23 681
Java NIO 编程 1.1 Java NIO 基本介绍 Java NIO 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的。 NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。 NIO 有三大核心部分：　 Channel(通道) ， Buffer(缓冲区
【网络编程系列】NIO
热门推荐
檀越的博客
05-03 2万+
💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝✨✨ 欢迎订阅本专栏 ✨✨。
网络编程NIO
柠檬树
02-25 659
一、NIO简介      NIO即Non-block I/O，非阻塞I/O，与Socket类和ServerSocket类相对应，NIO也提供了SocketChannel和ServerSocketChannel两种不同的套接字通道实现。          深入理解NIO之前呢，首先我们要了解与NIO有关的基本概念。如Buffer(缓冲区)、Channel(管道、通道)、Selector(选择器、...
NIO的实现原理
前路漫漫，少年，继续披荆斩棘！
04-06 2814
NIO的实现原理
NIO流原理解析
root
05-22 698
在 JDK1.4 之后，为了提高 Java IO 的效率，Java 又提供了一套 New IO（NIO），原因在于它相对于之前的 IO 类库是新增的。此外，旧的 IO 类库提供的 IO 方法是阻塞的，New IO 类库则让 Java 可支持非阻塞 IO，所以，更多的人喜欢称之为非阻塞 IO（Non-blocking IO）。 一、NIO网络模型 1、NIO网络模型猜想？ Acceptor：接受客户端连接请求。 当客户端有连接请求之后，服务端会创建一个scoket，将它放入一个set集合中，.
NIO 非阻塞 --网络编程原理分析
MrH12355的博客
09-16 141
NIO 非阻塞 --网络编程原理分析
Netty应用(一) 之 NIO概念 & 基本编程
最新发布
Eriksen的博客
02-10 1585
Netty应用(一) 之 NIO概念 & 基本编程
深入理解java里nio的非阻塞
03-26
Java NIO（New IO）包含了非阻塞的IO操作。传统的Java IO类库是基于流（stream）的，这意味着每个操作都是阻塞的，即程序必须等待操作完成才能进行下一步操作。相反，Java NIO是基于缓冲区（Buffer）和通道（Channel）的，允许程序异步地读取和写入数据，而不需要阻塞等待。这就是非阻塞IO的概念。 对于Java NIO，一个（同步）线程可以同时处理多个连接（通道），这样就可以避免创建大量的线程。此外，Java NIO还提供了选择器（Selector）的概念，可以检查多个通道是否准备好进行读写操作，从而进一步提高效率。 需要注意的是，Java NIO的非阻塞性是相对的，因为在一些情况下还是需要等待数据的到来或数据的处理结束才能进行下一步操作。 总之，Java NIO的非阻塞IO可以使程序更好地利用资源，提高吞吐量和性能表现，尤其适用于处理高并发的网络应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值