NIO编程从入门到...

最新推荐文章于 2024-08-07 20:21:08 发布
最新推荐文章于 2024-08-07 20:21:08 发布
阅读量89 收藏
点赞数 1
分类专栏： 笔记 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/htydowd/article/details/119805180
版权

小学生，用最简单的方式 写一个 NIO 服务端


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
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 Test {

    static Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) {

        try {

            // 开启 selector
            Selector selector = Selector.open();

            // 开启 ServerSocketChannel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress("127.0.0.1",8888));
            serverSocketChannel.configureBlocking(false);

            // 将 channel 注册到 selector中。 ServerSocketChannel 只能注册 OP_ACCEPT 事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            while (true) {

                // 监听 channel事件
                int select = selector.select();
                if (select == 0){
                    continue;
                }

                // 遍历 channel事件
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()){
                    SelectionKey key = iterator.next();

                    // 连接事件
                    if (key.isAcceptable()){
                        // 这里只能是 ServerSocketChannel
                        ServerSocketChannel channel = (ServerSocketChannel) key.channel();

                        // 获取 新的连接 channel
                        SocketChannel socketChannel = channel.accept();
                        socketChannel.configureBlocking(false);

                        // 设置 新的连接channel 关注的事件
                        // 关注 OP_READ
                        socketChannel.register(selector, SelectionKey.OP_READ);
                    }

                    // 读事件
                    if (key.isReadable()){
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        ByteBuffer attachment = ByteBuffer.allocate(1024);
                        socketChannel.read(attachment);
                        attachment.flip();
                        // 模拟业务处理时间
                        Thread.sleep(1000 * 3);

                        log.info(new String(attachment.array()).trim());
                        attachment.clear();
                        // 关注 OP_WRITE
                       socketChannel.register(selector,SelectionKey.OP_WRITE);
                    }

                    // 写事件
                    if (key.isWritable()){
                        SocketChannel socketChannel = (SocketChannel) key.channel();

                        // 模拟业务处理时间
                        Thread.sleep(1000 * 3);
                        socketChannel.write(ByteBuffer.wrap("hello,i am server".getBytes()));
                        // 关闭连接
                        key.cancel();
                        socketChannel.close();
                    }

                    // 移除
                    iterator.remove();
                }
            }
        }catch (Exception e){
            log.error("error " ,e);
        }
    }
}

初中生，开始想用多线程，但是写的有问题

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class Test {

    static Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) {

        try {

            // 开启 selector
            Selector selector = Selector.open();

            // 开启 ServerSocketChannel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress("127.0.0.1",8888));
            serverSocketChannel.configureBlocking(false);

            // 将 channel 注册到 selector中。 ServerSocketChannel 只能注册 OP_ACCEPT 事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            int i=0;
            while (true) {

                // 监听 channel事件
                int select = selector.select();
                if (select == 0){
                    continue;
                }
                Thread t = new Thread(() -> {
                    try {

                        /**
                         * 启用一个新的线程 来处理 channel 事件。
                         *
                         * 新建立的 客户端连接 SocketChannel ,也 注册到了 当前的 selector
                         *
                         * 那么，这个线程启动之后，主线程 的 selector.select() 一直 返回 0
                         */
                        doSelector(selector);
                    } catch (Exception e) {
                        log.error("doSelector error", e);
                    }
                });
                t.setName("doSelector-" + (i++));
                t.start();

            }
        }catch (Exception e){
            log.error("error " ,e);
        }
    }

    private static void doSelector(Selector selector) throws IOException, InterruptedException {
        // 遍历 channel事件
        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
        while (iterator.hasNext()){
            SelectionKey key = iterator.next();

            // 连接事件
            if (key.isAcceptable()){
                // 这里只能是 ServerSocketChannel
                ServerSocketChannel channel = (ServerSocketChannel) key.channel();

                // 获取 新的连接 channel
                SocketChannel socketChannel = channel.accept();
                socketChannel.configureBlocking(false);

                // 设置 新的连接channel 关注的事件
                // 关注 OP_READ
                socketChannel.register(selector, SelectionKey.OP_READ);
            }

            // 读事件
            if (key.isReadable()){
                SocketChannel socketChannel = (SocketChannel) key.channel();
                ByteBuffer attachment = ByteBuffer.allocate(1024);
                socketChannel.read(attachment);
                attachment.flip();
                // 模拟业务处理时间
                Thread.sleep(1000 * 3);

                log.info(new String(attachment.array()).trim());
                attachment.clear();
                // 关注 OP_WRITE
               socketChannel.register(selector,SelectionKey.OP_WRITE);
            }

            // 写事件
            if (key.isWritable()){
                SocketChannel socketChannel = (SocketChannel) key.channel();

                // 模拟业务处理时间
                Thread.sleep(1000 * 3);
                socketChannel.write(ByteBuffer.wrap("hello,i am server".getBytes()));
                // 关闭连接
                key.cancel();
                socketChannel.close();
            }

            // 移除
            iterator.remove();
        }
    }
}

然后 初中生 开始 改进了，但是还有问题


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class Test {

    static Logger log = LoggerFactory.getLogger(Test.class);

    // 检测 线程启动情况
    static volatile boolean start = false;

    public static void main(String[] args) {

        try {

            // 开启 selector，只监听 客户端的连接事件
            Selector selector = Selector.open();

            // 开启 selector ,用来 监听 客户端的 读写事件
            Selector selector2 = Selector.open();

            // 开启 ServerSocketChannel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress("127.0.0.1",8888));
            serverSocketChannel.configureBlocking(false);

            // 将 channel 注册到 selector中。 ServerSocketChannel 只能注册 OP_ACCEPT 事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            int i=0;
            while (true) {

                // 监听 channel事件
                int select = selector.select();
                if (select == 0){
                    continue;
                }

                // 将 客户端的连接事件，注册到 selector2 中
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isAcceptable()) {
                        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                        SocketChannel socketChannel = channel.accept();
                        socketChannel.configureBlocking(false);

                        /**
                         *  每次 接手到的 新的客户端连接 注册到 selector2 中，
                         *  第一个线程进来是好的，当有第二个连接进来时，main线程 被 block了。
                         *
                         *  main线程 和 doSelector-0 线程 同时 操作 selector2，存在线程安全问题
                         */
                        socketChannel.register(selector2, SelectionKey.OP_READ);
                    }

                    // 这个不要忘记
                    iterator.remove();
                }

                if (!start) {
                    Thread t = new Thread(() -> {
                        try {
                            /**
                             * 起一个 新的 线程，只用来处理 selector2中的 客户端的 读写事件
                             */
                            while (true){
                                int count = selector2.select();
                                if (count == 0){
                                    continue;
                                }
                                doSelector2(selector2);
                            }
                        } catch (Exception e) {
                            log.error("doSelector error", e);
                        }
                    });
                    t.setName("doSelector-" + (i++));
                    t.start();
                    start = true;
                }

            }
        }catch (Exception e){
            log.error("error " ,e);
        }
    }

    private static void doSelector2(Selector selector) throws IOException, InterruptedException {
        // 遍历 channel事件
        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
        while (iterator.hasNext()){
            SelectionKey key = iterator.next();
            // 读事件
            if (key.isReadable()){
                SocketChannel socketChannel = (SocketChannel) key.channel();
                ByteBuffer attachment = ByteBuffer.allocate(1024);
                socketChannel.read(attachment);
                attachment.flip();
                // 模拟业务处理时间
                Thread.sleep(1000 * 3);

                log.info(new String(attachment.array()).trim());
                attachment.clear();
                // 关注 OP_WRITE
               socketChannel.register(selector,SelectionKey.OP_WRITE);
            }

            // 写事件
            if (key.isWritable()){
                SocketChannel socketChannel = (SocketChannel) key.channel();

                // 模拟业务处理时间
                Thread.sleep(1000 * 3);
                socketChannel.write(ByteBuffer.wrap("hello,i am server".getBytes()));
                // 关闭连接
                key.cancel();
                socketChannel.close();
            }

            // 移除
            iterator.remove();
        }
    }
}

终于，初中生 写出了 一个 线程 处理连接事件，一个线程 处理 读写事件的 NIO 服务端


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class Test {

    static Logger log = LoggerFactory.getLogger(Test.class);

    // 检测 线程启动情况
    static volatile boolean start = false;

    // 任务队列，保存 新的连接SocketChannel
    static BlockingQueue<Runnable> queue = new LinkedBlockingDeque();

    public static void main(String[] args) {

        try {

            // 开启 selector，只监听 客户端的连接事件
            Selector selector = Selector.open();

            // 开启 selector ,用来 监听 客户端的 读写事件
            Selector selector2 = Selector.open();

            // 开启 ServerSocketChannel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress("127.0.0.1",8888));
            serverSocketChannel.configureBlocking(false);

            // 将 channel 注册到 selector中。 ServerSocketChannel 只能注册 OP_ACCEPT 事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            int i=0;
            while (true) {

                // 监听 channel事件
                int select = selector.select();
                if (select == 0){
                    continue;
                }

                // 将 客户端的连接事件，注册到 selector2 中
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isAcceptable()) {
                        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                        SocketChannel socketChannel = channel.accept();


                        // 将新的连接 放入 队列中
                        queue.add(()->{
                            try {
                                socketChannel.configureBlocking(false);
                                socketChannel.register(selector2, SelectionKey.OP_READ);
                            }catch (Exception e){
                                log.error("add error",e);
                            }

                        });

                        /**
                         * 为了 防止 与 selector2 绑定的 线程，在执行 selector2.select() 时 阻塞
                         * 这里需要 调用  selector2.wakeup(); 来唤醒
                         */
                        selector2.wakeup();
                    }

                    // 这个不要忘记
                    iterator.remove();
                }

                if (!start) {
                    Thread t = new Thread(() -> {
                        try {
                            /**
                             * 起一个 新的 线程，只用来处理 selector2中的 客户端的 读写事件
                             */
                            while (true){
                                /**
                                 * 用非阻塞的方法 从队列中拿任务，如果拿不到则立即返回。
                                 * 因为程序需要继续监听 已经注册到 selector2中的 事件
                                 */
                                Runnable take = queue.poll();
                                if (take != null){
                                    take.run();
                                }

                                /**
                                 * 如果 selector2中 一直 没有 事件发生，则 当前线程会一直 阻塞在这里
                                 * 当有新的连接请求进来时，即使 队列中 存在任务，也没办法处理。
                                 * 所以，需要在 有新连接请求时，执行 selector2.wakeup(); 来唤醒
                                 */
                                int count = selector2.select();
                                if (count == 0){
                                    continue;
                                }
                                doSelector2(selector2);
                            }
                        } catch (Exception e) {
                            log.error("doSelector error", e);
                        }
                    });
                    t.setName("doSelector-" + (i++));
                    t.start();
                    start = true;
                }

            }
        }catch (Exception e){
            log.error("error " ,e);
        }
    }

    private static void doSelector2(Selector selector) throws IOException, InterruptedException {
        // 遍历 channel事件
        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
        while (iterator.hasNext()){
            SelectionKey key = iterator.next();
            // 读事件
            if (key.isReadable()){
                SocketChannel socketChannel = (SocketChannel) key.channel();
                ByteBuffer attachment = ByteBuffer.allocate(1024);
                socketChannel.read(attachment);
                attachment.flip();
                // 模拟业务处理时间
                Thread.sleep(1000 * 3);

                log.info(new String(attachment.array()).trim());
                attachment.clear();
                // 关注 OP_WRITE
               socketChannel.register(selector,SelectionKey.OP_WRITE);
            }

            // 写事件
            if (key.isWritable()){
                SocketChannel socketChannel = (SocketChannel) key.channel();

                // 模拟业务处理时间
                Thread.sleep(1000 * 3);
                socketChannel.write(ByteBuffer.wrap("hello,i am server".getBytes()));
                // 关闭连接
                key.cancel();
                socketChannel.close();
            }

            // 移除
            iterator.remove();
        }
    }
}

NIO 如果只用单线程 发挥不出 其优势，必须用多线程。

一个线程 处理 连接事件

一个线程处理 读写事件

还是比较容易：

处理连接事件的线程有一个自己的 selector。有新连接请求时，将 新的连接 包装成一个 任务，丢到 队列中，并且 唤醒 读写事件的 线程

读写事件的线程也有一个自己的 selector。从队列中拿任务，如果有，则执行任务，然后处理自己的 selector

各自维护 一个 selector，通过 任务队列 来 处理 新的 连接请求。同时注意， 从队列中拿任务时，不能 用 阻塞的方法。

那么，怎么才能更大的提高效率， 用多个 处理连接请求的 线程 和 多个 处理 读写请求的 线程 来完成 NIO 服务端呢？

高中生是这样做的...

LSZXZNJ
关注
专栏目录
java 异步写文件_Java NIO 学习笔记（六）----异步文件通道 AsynchronousFileChannel
weixin_28720573的博客
02-12 871
AsynchronousFileChannel 异步文件通道在 Java 7 中，AsynchronousFileChannel 已添加到 Java NIO 中，它可以异步读取数据并将数据写入文件。先说明，异步和阻塞/非阻塞没有关系，下面简单介绍一下相关概念：阻塞是线程的一个状态，线程发起任务请求然后一直等，直到到任务完成再把结果返回，如果任务未完成当前线程会被挂起。非阻塞是发起任务请求之后先马上...
Java编程语言入门学习建议.zip
01-27
总的来说，Java编程语言的学习涉及众多方面，从基础语法到高级特性，都需要时间和精力去掌握。这个压缩包中的"Java编程语言入门学习建议.pdf"很可能会提供详细的步骤和实用技巧，帮助初学者少走弯路，更高效地入门...
03-Java NIO 编程 入门
彼岸舞的博客
01-21 268
NIO 基本介绍 Java NIO 全称 java non-blocking IO,是指JDK提供的新API,从JDK1.4提供了一系列改进的输入/输出的新特性,被统称为NIO(即New IO),是同步非阻塞的 NIO 相关类都被放在java.nio包及子包下,并对原Java.io包中的很多类进行改写.[基本案例] NIO 有三大核心部分: Channel(通道),Buffer(缓冲区),...
Java NIO 快速入门：Java 非阻塞 IO 编程详解
m0_64516972的博客
07-17 1566
Java NIO（New Input/Output）是一套从Java 1.4开始引入的高效IO库，旨在替代传统的阻塞式IO。它通过非阻塞模式和多路复用技术，极大地提升了并发性能，非常适合高并发场景。本文将以简单易懂的方式带你入门Java NIO，轻松掌握其核心概念和实际应用。
NIO网络编程入门
qq_46863837的博客
05-08 897
服务器端代码客户端代码。
【Java】NIO-从入门到精通-Netty先修课-全网最全-综合案例分析
最新发布
XYC的学习经验博客
08-07 763
Java NIO的零拷贝技术通过减少数据在用户空间和内核空间之间的拷贝次数，以及减少上下文切换，显著提高了数据传输的效率。这对于网络编程和文件处理等需要大量数据传输的场景尤为重要。Java NIO中的Files类提供了一系列静态方法来简化文件操作，包括文件的创建、删除、拷贝等。使用Files类可以轻松实现文件的多级拷贝，即从一个目录拷贝整个目录结构及其文件到另一个位置。在Java NIO中，尽管NIO以其非阻塞特性而闻名，但它也支持阻塞操作。
Java编程：从入门到精通
weixin_45990682的博客
06-20 1286
Java凭借其跨平台特性、强大的面向对象编程能力和丰富的类库，成为现代软件开发的中坚力量。通过不断学习和实践，掌握Java编程不仅能提升个人技术水平，还能为职业发展打开更多可能性。希望这篇文章能为Java初学者提供清晰的学习路径，也为有经验的开发者提供一些新的思路和灵感。无论你处于何种编程水平，Java的世界都值得深入探索。欢迎大家在评论区分享你的Java学习经验和心得，共同交流进步！
三、JAVA NIO 编程
donkeyboy001的博客
08-04 309
JAVA NIO 编程
NIO编程简单入门
liuerchong的博客
07-13 281
NIO编程 NIO概述 什么是NIO? Java NIO(New IO)是一个可以替代标准Java IO API的IO API（从Java 1.4开始)，Java NIO提供了与标准IO不同的IO工作方式。 Java NIO: Channels and Buffers（通道和缓冲区） 标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。 Java NIO: Non-blocking
NIO编程入门
weixin_61557810的博客
05-19 280
NIO编程
java nio 编程_JAVA NIO编程入门（一）
weixin_35782250的博客
02-15 148
一、前言笔者之前接触的NIO编程比较少，所以对这一块的基础也比较弱，NIO作为java编程中一个重要的模块，不能很好的掌握它，感觉自己在java方面就掌握的不够，所以，接下来，笔者会学习NIO编程，所以，该系列文章不会涉及到很深源码解析，纯粹的是学习课程，也可以理解为笔者的笔记，记录学习NIO的过程，同时也希望这类文章可以对同样想掌握NIO编程的你有帮助。二、什么是NIO？Java NIO(New...
从NIO到Netty，编程实战出租车905协议-08172347.pdf
06-11
905.4-2014协议，是交通运输部公路科学研究院起草定制的一个协议标准，它也是基于TCP之上的一个应用层传输协议。 第2章，介绍在Socket编程过程中一些基础知识，让大家建立起对这块知识...想通过实战入门NIO、Netty。
Javajava编程从入门到大师28课+EditPlus
04-19
【Java编程从入门到大师28课+EditPlus】是一套全面且深入的Java学习资源，旨在帮助初学者快速掌握Java编程技能，并逐渐晋升为专业开发者。本套课程结合了28个精心设计的课程，涵盖了Java编程的基础概念、语法特性、...
NIO 入门.chm,NIO 入门.chm
04-10
**NIO（New Input/Output）是Java编程语言中用于替代标准I/O（BIO，Blocking I/O）的一组API，它提供了非阻塞式的I/O操作方式，极大地提升了Java在处理I/O密集型应用时的性能。NIO在Java 1.4版本中被引入，之后在...
ERROR 1130 (HY000): Host ‘localhost‘ is not allowed to connect to this MySQL server
htydowd的博客
04-26 7217
mysql 版本 5.6.24 安装环境 windows ERROR 1130 (HY000) 这个错误，表示 当前主机没有权限 连接 到mysql 服务。 如果是自己 本地 windows 安装的，用来自己学习使用，那么可以用这个方法： 第一步: 首先 关闭 mysql 服务 计算机管理---服务 找到mysql ，关闭就可以了 第二步： CMD打开： 执行 mysqld --skip-grant-tables 这样就可以正常连接mysql了。 第三步： 更新 mys
实际包存在，编译时报包不存在
htydowd的博客
05-15 6757
问题： 运行程序报错：程序包不存在 实际是存在的，idea也不报错，只是编译是会报错。 解决过程： maven配置、重新导入包、包的scope、JDK版本、重启IDEA等等都试了，还是不行。 解决问题： 执行 命令 mvn idea:idea 再此编译OK： ...
Mybatis查询 字段类型转换错误
htydowd的博客
04-19 5742
问题描述： Cannot convert string 'aaa' to java.sql.Timestamp value; nested exception is java.sql.SQLDataException: Cannot convert string 'aaa' to java.sql.Timestamp value at org.springframework.jdbc.support.SQLExceptionSubclassTranslator.doTranslate(SQLExc.
读取文件流的几种方式
htydowd的博客
02-10 3508
计算机只认识 0 1 这种二进制流，不论是网络传输还是磁盘文件，在被计算机的程序处理之前，都是以二进制流的形式 进入计算机程序的，计算机程序获取到二进制流之后，再进行转换，也就是 序列化和反序列化。 对于网络上的二进制流，通常是用 Socket 来获取 InputStream 和 OutputStream 进行 输入和输出流的处理。 对于磁盘上来说，需要将 磁盘上的 文件 (例如：文本文件、视频文件、音频文件、图片等) 读取到程序中，这个过程 有哪些方法来实现呢？ 1. JDK 提供的 Inp
深入理解Java NIO：从入门到实践
"NIO入门.pdf" NIO（New Input/Output）是Java开发工具包（JDK）1.4版本引入的一个新特性，主要用来解决传统I/O...通过本教程的学习，你将深入理解NIO库的高级概念和底层细节，为你的Java NIO编程打下坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值