netty（二）基础 多线程情况下的selector

已于 2022-08-13 18:26:55 修改
阅读量517 收藏 1
点赞数
分类专栏： netty 文章标签： java docker 开发语言
于 2022-08-13 17:37:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45699541/article/details/126307746
版权

selector多线程设计

在这里插入图片描述
在这里插入图片描述

package com.example.nettytest01;

import com.google.common.primitives.Chars;
import lombok.extern.slf4j.Slf4j;
import org.omg.SendingContext.RunTime;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;


@Slf4j
public class ThreadsServer {
    public static void main(String[] args) {
        try (ServerSocketChannel server = ServerSocketChannel.open()) {
            // 当前线程为Boss线程
            Thread.currentThread().setName("Boss");
            server.bind(new InetSocketAddress(8081));
            // 负责轮询Accept事件的Selector
            Selector boss = Selector.open();
            server.configureBlocking(false);
            server.register(boss, SelectionKey.OP_ACCEPT);
            // 创建固定数量的Worker //Runtime.getRuntime().availableProcessors(): 获得可用核心线程数量
                                    // 但是在docker 容器中 假设给容器分配一核  他会拿到 主机的全部 内核数量 ！！！jdk10修复
            Worker[] workers = new Worker[Runtime.getRuntime().availableProcessors()];
            // 用于负载均衡的原子整数
            AtomicInteger robin = new AtomicInteger(0);
            for(int i = 0; i < workers.length; i++) {
                workers[i] = new Worker("worker-"+i);
            }
            while (true) {
                boss.select();
                Set<SelectionKey> selectionKeys = boss.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();
                    // BossSelector负责Accept事件
                    if (key.isAcceptable()) {
                        // 建立连接
                        SocketChannel socket = server.accept();
                        System.out.println("connected...");
                        socket.configureBlocking(false);
                        // socket注册到Worker的Selector中
                        System.out.println("before read...");
                        // 负载均衡，轮询分配Worker  getAndIncrement：自增
                        workers[robin.getAndIncrement()% workers.length].register(socket);
                        System.out.println("after read...");
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class Worker implements Runnable {
        private Thread thread;
        private volatile Selector selector;
        private String name;
        private volatile boolean started = false;
        /**
         * 同步队列，用于Boss线程与Worker线程之间的通信
         */
        private ConcurrentLinkedQueue<Runnable> queue;

        public Worker(String name) {
            this.name = name;
        }

        public void register(final SocketChannel socket) throws IOException {
            // 只启动一次
            if (!started) {
                thread = new Thread(this, name);
                selector = Selector.open();
                queue = new ConcurrentLinkedQueue<>();
                thread.start();
                started = true;
            }

            // 向同步队列中添加SocketChannel的注册事件
            // 在Worker线程中执行注册事件
            queue.add(new Runnable() {
                @Override
                public void run() {
                    try {
                        socket.register(selector, SelectionKey.OP_READ);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            // 唤醒被阻塞的Selector
            // select类似LockSupport中的park，wakeup的原理类似LockSupport中的unpark
            selector.wakeup();
        }

        @Override
        public void run() {
            while (true) {
                try {
                    selector.select();
                    log.info("线程已经开启lo~~");
                    // 通过同步队列获得任务并运行
                    Runnable task = queue.poll();
                    if (task != null) {
                        // 获得任务，执行注册操作
                        task.run();
                    }
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    while(iterator.hasNext()) {
                        SelectionKey key = iterator.next();
                        iterator.remove();
                        // Worker只负责Read事件
                        if (key.isReadable()) {
                            // 简化处理，省略细节
                            log.info("work.selector收到一个读事件~~");
                            SocketChannel socket = (SocketChannel) key.channel();
                            ByteBuffer buffer = ByteBuffer.allocate(16);
                            socket.read(buffer);
                            buffer.flip();
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端

package com.example.nettytest01;

import com.google.common.primitives.Chars;
import lombok.extern.slf4j.Slf4j;
import org.omg.SendingContext.RunTime;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;


@Slf4j
public class ThreadsServer {
    public static void main(String[] args) {
        try (ServerSocketChannel server = ServerSocketChannel.open()) {
            // 当前线程为Boss线程
            Thread.currentThread().setName("Boss");
            server.bind(new InetSocketAddress(8081));
            // 负责轮询Accept事件的Selector
            Selector boss = Selector.open();
            server.configureBlocking(false);
            server.register(boss, SelectionKey.OP_ACCEPT);
            // 创建固定数量的Worker //Runtime.getRuntime().availableProcessors(): 获得可用核心线程数量
                                    // 但是在docker 容器中 假设给容器分配一核  他会拿到 主机的全部 内核数量 ！！！jdk10修复
            Worker[] workers = new Worker[Runtime.getRuntime().availableProcessors()];
            // 用于负载均衡的原子整数
            AtomicInteger robin = new AtomicInteger(0);
            for(int i = 0; i < workers.length; i++) {
                workers[i] = new Worker("worker-"+i);
            }
            while (true) {
                boss.select();
                Set<SelectionKey> selectionKeys = boss.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();
                    // BossSelector负责Accept事件
                    if (key.isAcceptable()) {
                        // 建立连接
                        SocketChannel socket = server.accept();
                        System.out.println("connected...");
                        socket.configureBlocking(false);
                        // socket注册到Worker的Selector中
                        System.out.println("before read...");
                        // 负载均衡，轮询分配Worker  getAndIncrement：自增
                        workers[robin.getAndIncrement()% workers.length].register(socket);
                        System.out.println("after read...");
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class Worker implements Runnable {
        private Thread thread;
        private volatile Selector selector;
        private String name;
        private volatile boolean started = false;
        /**
         * 同步队列，用于Boss线程与Worker线程之间的通信
         */
        private ConcurrentLinkedQueue<Runnable> queue;

        public Worker(String name) {
            this.name = name;
        }

        public void register(final SocketChannel socket) throws IOException {
            // 只启动一次
            if (!started) {
                thread = new Thread(this, name);
                selector = Selector.open();
                queue = new ConcurrentLinkedQueue<>();
                thread.start();
                started = true;
            }

            // 向同步队列中添加SocketChannel的注册事件
            // 在Worker线程中执行注册事件
            queue.add(new Runnable() {
                @Override
                public void run() {
                    try {
                        socket.register(selector, SelectionKey.OP_READ);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            // 唤醒被阻塞的Selector
            // select类似LockSupport中的park，wakeup的原理类似LockSupport中的unpark
            selector.wakeup();
        }

        @Override
        public void run() {
            while (true) {
                try {
                    selector.select();
                    log.info("线程已经开启lo~~");
                    // 通过同步队列获得任务并运行
                    Runnable task = queue.poll();
                    if (task != null) {
                        // 获得任务，执行注册操作
                        task.run();
                    }
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    while(iterator.hasNext()) {
                        SelectionKey key = iterator.next();
                        iterator.remove();
                        // Worker只负责Read事件
                        if (key.isReadable()) {
                            // 简化处理，省略细节
                            log.info("work.selector收到一个读事件~~");
                            SocketChannel socket = (SocketChannel) key.channel();
                            ByteBuffer buffer = ByteBuffer.allocate(16);
                            socket.read(buffer);
                            buffer.flip();
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

阻塞io

在这里插入图片描述
复制数据是 查询完毕的数据写入 java缓存里面
在这里插入图片描述

在这里插入图片描述
阻塞io的缺点：在做一件事情的时候做不了另一件事 。 在处理read事件无法 处理新用户的accept事件

多路复用

一个线程解决多个请求 ，select可以监听多个事件 ，一次性接收多个事件并且处理 。像一个漏斗，可以好几个进（接收事件），
一个个出（处理）
在这里插入图片描述
同步：线程自己去获取结果
阻塞io 是同步的 。
在这里插入图片描述
非阻塞io也是同步的
在这里插入图片描述
多路复用
在这里插入图片描述

异步：线程自己不去获取结果 ，由 其他线程递送结果
通过回调方法 来接收结果 ，相当于叫小弟 去买烟 自己等待

不存在 异步阻塞 ，异步天然非阻塞！！异步自己可以去淦别的事情
在这里插入图片描述

socket文件读写

在这里插入图片描述
图1.1
java本身不具备io 读写能力 ， 是操作系统帮他完成的 。
在这里插入图片描述
图1.1 一共发生了四次io 读写 3次内核态用户态切换 。

nio优化

在这里插入图片描述
通过DirectByteBuf优化

ByteBuffer.allcate(10) HeaoByteBuffer 使用的是java内存
ByteBuffer.allcateDirect（10）DirectByteBuffer 使用的是操作系统内存
相对于图1.1 少一次io读写

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

零拷贝 ： 文件不需要经过java缓冲区 ，但是知识和小文件

异步非阻塞 在springboot响应式编程中发光发热！！ 天然干高并发

Netty框架之多线程的Selector优化
TheWayForDream
04-26 732
Netty框架之多线程的Selector优化1.一个Boss线程，一个Woker线程实现服务器2.一个Boss线程，多个Woker线程实现服务器 学习Selector之后，我们发现单个Selector轮询器在一个线程中既要处理连接事件(OP_ACCPET)，又要处理IO读写事件(OP_READ,OP_WRITE)，效率是很低的，所以利用多线程创建多个Selector分别负责连接事件，IO读写事件，充分利用电脑的CPU资源. 那么这里我们就分类两个线程： 1.Boss线程：专门负责OP_ACCPET事件，也就
netty客户端引发的线程血案（二）
joniers的博客
08-14 3836
netty客户端引发的线程血案（二） 前言 前文讲解了基于netty-client 3.10.5如何出现的线程雪崩，在分析该问题的过程中，我们切换了es-client调用的netty库，尝试使用了netty的一些老的版本，发现，在3.2.4版本上面不存在该问题，这是什么原因导致的呢？
使用Netty实现多路复用的client
weixin_34357267的博客
05-25 645
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty多线程 和 Redis6 多线程对比
Java圈全能架构师的博客
04-02 399
Redis 6引入多线程IO，下面我们来和 Netty 的多线程模型进行对比 分析思路： 初始化线程？ 如何分配client给thread？ 如何处理读写事件，在什么线程处理？ 如何处理命令的逻辑，在什么线程处理？ Netty的多线程模型 用户代码 ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerS.
使用Netty4实现多线程的消息分发
04-25
使用Netty4实现多线程的消息分发,这是一个基于netty4做的一个异步通信模型。
多线程改进Selector
weixin_47395433的博客
11-03 470
前面的代码在服务器端都是单线程配合一个 Selector 选择器来管理多个 channel 上的事件 这样有两个缺点 现在都是多核CPU，一个线程只能用一个核心，其他的核心会白白浪费 单线程是可以处理多个事件，但是如果某个事件耗时较长，就会造成其他事件的等待 如果让你设计一种较为合理的架构，你会怎样设计呢？ 首先一点要把多核CPU 充分利用起来，第二就是每个线程对应自己的职责，例如，店小二负责接待，厨师负责炒菜，服务员负责记录菜单 代码实现 服务器 package com.zhao.c.
【Netty系列】NIO编程案例（Selector）
Love Peace
04-26 585
Java的NIO，用非阻塞的IO方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector（选择器）。Selector 能够检测多个注册的通道上是否有事件发生（注意：多个Channel以事件的方式可以注册到同一个Selector），如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。只有在连接/通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程。
深入解析 Netty 的线程模型
最新发布
持续分享有趣的技术干货
09-05 1270
Netty 的线程模型通过巧妙地结合和优化传统的线程处理方式，提供了一种高效、灵活且可扩展的解决方案，适用于各种高并发的网络应用场景。理解和选择合适的线程模型对于构建高性能的网络应用至关重要。我是马丁，一名专注于网络编程技术的开发者，经常在 优快云 平台分享技术心得。希望本文能对您有所帮助，欢迎大家三连加关注，一起交流探讨更多技术话题！
02-VIP-Netty核心功能与线程模型精讲1
08-03
在分布式系统中，例如阿里 Dubbo 的 RPC 框架，以及 RocketMQ 消息中间件，都依赖 Netty 作为基础通信组件，实现高效的数据传输和节点间的通信。此外，Hadoop 的高性能通信组件 Avro RPC 也使用 Netty 进行跨节点...
Netty代码示例及Reactor主从多线程模型
qq_38517570的博客
03-06 498
Netty
Netty学习2—传统多线程服务端
weixin_33912246的博客
12-18 177
1 代码 import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util...
Netty的SelectorProvider
u013828625的博客
03-30 846
package java.nio.channels.spi; import java.io.IOException; import java.net.ProtocolFamily; import java.nio.channels.*; import java.security.AccessController; import java.security.PrivilegedAction; im...
开源异步并行框架，完成任意的多线程编排、阻塞、等待、串并行结合、强弱依赖
tianyaleixiaowu的专栏
01-14 3387
本文首发于京东零售公众号，https://mp.weixin.qq.com/s/17OAAbCKQND-AjTdf43TGw netty是一个经典的网络框架，提供了基于NIO、AIO的方式来完成少量线程支持海量用户请求连接的模型。netty里面充斥了大量的非阻塞回调模式，主要是靠Future/Promise异步模型来实现的。 Future是java.util.concurrent.Future...
Netty学习之---Selector
qq_35529931的博客
05-29 475
在入门学习netty的时候，我们就写过一个简单client连接service的代码； 1:client代码 public static void main(String[] args) throws Exception{ SocketChannel sc = SocketChannel.open(); sc.connect(new InetSocketAddress("localhost",8080)); System.out.println("waitin
（五）Netty之Selector选择器
大叶子不小的博客
02-15 586
System.out.println("客户端连接成功 生成了一个 socketChannel " + socketChannel.hashCode());System.out.println("from 客户端:" + new String(buffer.array()));if (key.isAcceptable()) { //如果是OP_ACCEPT，有新的客户端连接。System.out.println("因为连接需要事件，客户端不会一直阻塞，可以做其他工作..");//设置或改变监听事件。
Netty多线程下响应消息乱序问题解决方案
恐龙弟旺仔的博客
02-15 3556
前言： 今天在看文章时，介绍了一个Netty_client被多线程调用发送消息出去，当服务端处理完成之后，将结果值返回给客户端，客户端无法区分是哪个线程的响应的问题的解决方案。 笔者之前在介绍Netty的代码时，其中关于Netty在Sentinel中的实战部分实际有介绍过这块，但是看代码的时候一直没有仔细想，今天看到这个问题，决定把这个问题再次详细描述下，然后把Sentinel的解决方案也再次说明下。 1.具体问题描述 在使用netty_client时，一般使用channel.writeAndF
Netty学习笔记（4）——Selector
江左煤郎的博客
10-12 3006
【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> ...
Netty框架之Selector使用详解
TheWayForDream
04-25 1650
谈到Selector的具体使用，那么就要结合BIO,NIO的知识讲解，Selector使用在非阻塞模式NIO场景下，学习NIO之前先要了解BIO原理，下面我们一步步讲解 一.BIO(Blocking-IO)-阻塞IO模式 先来看一下BIO下服务端的代码 public static void main(String[] args) throws Exception { //创建服务端通道 ServerSocketChannel ssc = ServerSocketChannel
Netty基础---NIO组件---Selector选择器(四)
ALiangXLogic的博客
03-28 3246
Selector(选择器) 在我们使用一个线程处理多个客户端的连接事件时就可以使用Selector ，Selector采用轮询的机制，去检测每条连接通道是否有事件发生，如果有事件发生，便可以根据发生的事件去做相应的处理，使用选择器之后，只有真正发生读写事件的时候才去启动线程读写，实现了一个线程管理多个通道，减少了多个线程上下文切换的开销 我们来看看Selector的模型图 这上面是简略图，意思就是多个客户端注册进Selector后，当有读写事件发生时，Selector去启动一个线程来完成读写操作 1.因为
Netty多线程实战深度解析与案例追踪
Netty多线程案例集锦是一系列文章，专门针对Netty这一高性能的网络通信框架中多线程应用的深入探讨和实践案例。Netty因其API的简洁性和丰富的Demo而被广泛用于入门，但随着技术栈的深入，很多开发者在实际项目中遇到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值