Netty -12- 任务加入异步线程池

最新推荐文章于 2024-07-21 14:36:17 发布
最新推荐文章于 2024-07-21 14:36:17 发布
阅读量845 收藏 4
点赞数
分类专栏： 网络编程 java 文章标签： netty java 网络 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44766883/article/details/107586921
版权

介绍

  1. 在 Netty 中做耗时的，不可预料的操作，比如数据库，网络请求，会严重影响 Netty 对 Socket 的处理速度。
  2. 而解决方法就是将耗时任务添加到异步线程池中。但就添加线程池这步操作来讲，可以有2种方式，而且这2种方式实现的区别也蛮大的。
    1. 处理耗时业务的第一种方式—handler 中加入线程池
    2. 处理耗时业务的第二种方式—Context 中添加线程池
      • 当我们使用addLast方法添加线程池后，handler将优先使用这个线程池，如果不添加，将使用IO线程

 流程


方式一

server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建BossGroup和WorkerGroup
        //bossGroup和workerGroup含有的子线程的个数，默认为cpu核数*2
        EventLoopGroup bossGroup=new NioEventLoopGroup(5);
        EventLoopGroup workerGroup=new NioEventLoopGroup();

        //创建服务器端的启动对象，配置参数
        ServerBootstrap  bootstrap=new ServerBootstrap();

        try {
            //使用链式编程来进行设置
            bootstrap.group(bossGroup,workerGroup)  //设置两个线程
                .channel(NioServerSocketChannel.class)  //使用NioServerSocketChannel，作为服务器的通道实现
                .option(ChannelOption.SO_BACKLOG,128)  //设置线程队列里连接个数
                .childOption(ChannelOption.SO_KEEPALIVE,true)//设置保持连接状态
                .childHandler(new ChannelInitializer<SocketChannel>() {  //handler对应的是boosGruop，childHandler对应的是workerGroup
                    //给pipeline设置处理器
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        //可以使用一个集合管理SocketChannel，在推送消息时，可以将业务加入到各个channel对应的
                        // NioEventLoop的taskQueue或者scheduleTaskQueue中
                        System.out.println("客户端socketChannel hashcode="+socketChannel.hashCode());
                        socketChannel.pipeline().addLast(new ServerHandler());
                    }
                });  //给我们的workerGroup的EventLoop对应的管道设置处理器
            System.out.println("服务器 is ready ...");

            //绑定一个端口并且同步，生成一个ChannelFuture对象
            ChannelFuture cf = bootstrap.bind(6668).sync();

            //给 cf 注册监听器，监控我们关心的事件
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if(future.isSuccess()){
                        System.out.println("监听端口成功");
                    }else{
                        System.out.println("监听端口失败");
                    }
                }
            });

            //对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

serverHandler
public class ServerHandler extends ChannelInboundHandlerAdapter {

    static final EventExecutorGroup group=new DefaultEventExecutorGroup(16);

    private final DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");



    /**
    * @Description 读取数据事件(这里我们可以读取客户端发送的消息)
    * @date 2020/7/23 10:33
    * @param ctx  上下文对象，含有：管道(pipeline),通道(channel),地址
    * @param msg  客户端发送的数据
    * @return void
    */
    @Override
    public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf=(ByteBuf)msg;
        System.out.println("接收到的消息："+buf.toString(CharsetUtil.UTF_8)+"  "+ LocalDateTime.now().format(formatter) +"  当前线程----"+Thread.currentThread().getName());

        //任务
        ctx.channel().eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("服务端发送消息1  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
                ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端1\t",CharsetUtil.UTF_8));
            }
        });

        ctx.channel().eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("服务端发送消息2  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
                ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端2\t",CharsetUtil.UTF_8));
            }
        });

        //定时任务
        ctx.channel().eventLoop().schedule(()->{
            System.out.println("服务端发送消息3  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
            ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端4\t",CharsetUtil.UTF_8));
        },10,TimeUnit.SECONDS);


        //将任务提交到group线程池
        group.submit(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                System.out.println("服务端发送消息4  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
                ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端4\t",CharsetUtil.UTF_8));
                return null;
            }
        });

        System.out.println("发送消息...");
    }

    /**
    * @Description 数据读取完毕
    * @date 2020/7/23 10:46
    * @param ctx  
    * @return void
    */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //将数据写入到缓冲并刷新
        //一般来讲，我们队发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer(new Date().toString()+":"+"hello,客户端",CharsetUtil.UTF_8));
    }

    /**
    * @Description 处理异常，一般是需要管理通道
    * @date 2020/7/23 11:13
    * @param ctx
    * @param cause
    * @return void
    */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.channel().close();
    }
}

核心代码
//将任务提交到group线程池
group.submit(new Callable<Object>() {
    @Override
    public Object call() throws Exception {
        System.out.println("服务端发送消息4  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端4\t",CharsetUtil.UTF_8));
        return null;
    }
});

运行


方式二

server
public class Server {

    static final EventExecutorGroup group=new DefaultEventExecutorGroup(2);

    public static void main(String[] args) throws IOException {
        //创建BossGroup和WorkerGroup
        //bossGroup和workerGroup含有的子线程的个数，默认为cpu核数*2
        EventLoopGroup bossGroup=new NioEventLoopGroup(5);
        EventLoopGroup workerGroup=new NioEventLoopGroup();

        //创建服务器端的启动对象，配置参数
        ServerBootstrap  bootstrap=new ServerBootstrap();

        try {
            //使用链式编程来进行设置
            bootstrap.group(bossGroup,workerGroup)  //设置两个线程
                .channel(NioServerSocketChannel.class)  //使用NioServerSocketChannel，作为服务器的通道实现
                .option(ChannelOption.SO_BACKLOG,128)  //设置线程队列里连接个数
                .childOption(ChannelOption.SO_KEEPALIVE,true)//设置保持连接状态
                .childHandler(new ChannelInitializer<SocketChannel>() {  //handler对应的是boosGruop，childHandler对应的是workerGroup
                    //给pipeline设置处理器
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        //可以使用一个集合管理SocketChannel，在推送消息时，可以将业务加入到各个channel对应的
                        // NioEventLoop的taskQueue或者scheduleTaskQueue中
                        System.out.println("客户端socketChannel hashcode="+socketChannel.hashCode());

                        //如果我们在addLast添加handler，前面有指定EventExecutorGroup,name该handler会优先加入到该线程池中
                        socketChannel.pipeline().addLast(group,new ServerHandler());
                    }
                });  //给我们的workerGroup的EventLoop对应的管道设置处理器
            System.out.println("服务器 is ready ...");

            //绑定一个端口并且同步，生成一个ChannelFuture对象
            ChannelFuture cf = bootstrap.bind(6668).sync();

            //给 cf 注册监听器，监控我们关心的事件
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if(future.isSuccess()){
                        System.out.println("监听端口成功");
                    }else{
                        System.out.println("监听端口失败");
                    }
                }
            });

            //对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

serverHandler
public class ServerHandler extends ChannelInboundHandlerAdapter {

    private final DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");



    /**
    * @Description 读取数据事件(这里我们可以读取客户端发送的消息)
    * @date 2020/7/23 10:33
    * @param ctx  上下文对象，含有：管道(pipeline),通道(channel),地址
    * @param msg  客户端发送的数据
    * @return void
    */
    @Override
    public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf=(ByteBuf)msg;
        System.out.println("接收到的消息："+buf.toString(CharsetUtil.UTF_8)+"  "+ LocalDateTime.now().format(formatter) +"  当前线程----"+Thread.currentThread().getName());

        //任务
        ctx.channel().eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("服务端发送消息1  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
                ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端1\t",CharsetUtil.UTF_8));
            }
        });

        ctx.channel().eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("服务端发送消息2  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
                ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端2\t",CharsetUtil.UTF_8));
            }
        });

        //定时任务
        ctx.channel().eventLoop().schedule(()->{
            System.out.println("服务端发送消息3  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
            ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端4\t",CharsetUtil.UTF_8));
        },10,TimeUnit.SECONDS);


        System.out.println("服务端发送消息4  "+LocalDateTime.now().format(formatter)+"  当前线程----"+Thread.currentThread().getName());
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello 客户端4\t",CharsetUtil.UTF_8));

        System.out.println("发送消息...");
    }

    /**
    * @Description 数据读取完毕
    * @date 2020/7/23 10:46
    * @param ctx  
    * @return void
    */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //将数据写入到缓冲并刷新
        //一般来讲，我们队发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer(new Date().toString()+":"+"hello,客户端",CharsetUtil.UTF_8));
    }

    /**
    * @Description 处理异常，一般是需要管理通道
    * @date 2020/7/23 11:13
    * @param ctx
    * @param cause
    * @return void
    */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.channel().close();
    }
}

核心代码
//如果我们在addLast添加handler，前面有指定EventExecutorGroup,name该handler会优先加入到该线程池中
socketChannel.pipeline().addLast(group,new ServerHandler());

运行


迷雾总会解
关注
专栏目录
Netty入门-Netty篇
又逢乱世
01-19 1450
Netty 是什么？、 EventLoop、 channel、 ChannelFuture、 sync 和 addListener 区别、 如何正确处理 客户端传输通道 channel 关闭以后的操作?、 优雅的结束进程、 Future & Promise、 jdk Future、 netty Future、 netty Promise、 Handler & Pipeline、 pipeline调试工具 EmbeddedChannel、 ByteBuf 读写操作、 调试 ByteBuf 的工具 log方法、
使用Netty4实现多线程的消息分发
04-25
使用Netty4实现多线程的消息分发,这是一个基于netty4做的一个异步通信模型。
Netty(四十三) - 任务加入异步线程池
yangxshn的博客
03-25 633
一、基本说明 1）、在 Netty 中做耗时的，不可预料的操作，比如数据库、网络请求，会严重影响 Netty 对 Socket 的处理速度。 2）、解决方案就是将耗时任务添加到异步线程池中。但是就添加线程池这步操作来讲，可以有2种方式： 处理耗时业务的第一种方式----handler中加入线程池 处理耗时业务的第二种方式----Context中添加线程池 二、处理耗时业务的两种方式 2.1 handler中加入线程池 @Sharable public class EchoServerHandler ex
Netty4-实战精华之EventLoop和线程模型详解
最新发布
通往IT大道的专栏
07-21 614
然而在一些无状态上下文中，它仍可被用于在多个 Channel 之间共享一些重度的或者代价昂贵的对象，甚至是事件。但在 Netty3 的模型，因这是个入站事件，需在调用线程中执行代码，然后将事件移交给 I/O 线程去执行，这会带来额外上下文切换开销。而 Netty 的线程模型强大又易用，正如 Netty 的宗旨：简化你的应用程序代码，同时最大限度提高性能和可维护性。除这种受限场景，传输所采用的不同事件处理实现，其线程模型也会严重影响排队的任务对整体系统性能影响。中所产生的所有事件，则解决了该问题。
Netty入门 - 任务加入异步线程池源码剖析
qq_33240556的博客
06-07 237
Netty 的任务异步执行机制通过EventLoop和实现。任务提交到任务队列中，由事件循环线程执行。通过run()方法实现了事件循环，确保高效地处理任务和 I/O 事件。通过对源码的剖析，可以深入理解 Netty 的异步执行模型及其高性能设计。
Java线程任务 创建一个单独的任务线程并提交到线程池中执行 案例
weixin_44131922的博客
08-23 1805
awaitTermination() 作用即： 阻塞，直到所有任务在 shutdown 请求后完成执行，或发生超时，或当前线程中断，以先发生的为准。在未来的某个时间执行给定的命令或任务，可能在一个新的线程中执行，也可能在一个线程池中执行，或在调用的线程中执行，这由 Executor 的实现决定。此时结果依旧一致 但是 main 方法没有停止运行，依旧处于运行中，添加 shutdown() 后其实任务已经停止。可见 awaitTermination() 作用与JDK 接口描述的一致 其实并不是必须的。
java线程池（2）-线程池添加任务的过程（原理）
qq_31964815的博客
12-11 5358
上一期简单的聊了一下线程池的创建。这一期我们就，稍微熟悉一下线程池执行任务的过程吧！    线程池的工作原理是怎么样的呢？     首先，我用图来说明吧！     这里可以看到有一个任务队列，然后还有一个工作的线程池。今天主要将的就是向任务队列中添加任务的过程！     对于线程池我们上一期是做了一个稍微的解释的。我们构建线程池的时候，无论我们传入队列或者是不传入最后都会有一个队列的。那么
netty-server端学习总结
qq_34266059的博客
03-01 1179
目录NIO基础概念REACTOR 模型零拷贝NETTY NIO基础概念 REACTOR 模型 reactor 模型是基于事件驱动的, 它将不同的事件分配给不同的处理器执行. Multiple reactors reactor 模型中的事件驱动, 是基于 i/o 多路复用机制实现的. 1 2 selector, nio 中的多路复用器, 负责注册、处理事件. netty中, 基于 Multiple reactors , 即多响应器模型. 部分 reactor 只负责响应连接事件, 其它负责响应处理读写事件
Netty学习笔记（五）Netty 异步模型，简单实现http服务
yangwen-bo的博客
04-23 996
Netty学习笔记（五）Netty 异步模型，简单实现http服务 Netty handle异步处理 当处理工作handler中有特别耗时间的任务，如果继续，则会造成任务的阻塞 可以使用异步处理，将任务提交到该channel对应的NioEventLoop的taskQueue任务执行队列中去异步执行 解决思路1： 用户程序自定义的普通任务（可加多个，按添加顺序依次执行（在同一个线程中）） 解决思路2： 用户自定义定时提交任务，该任务是添加到scheduleTaskQueue中执行的 解决思路3： 非当前
netty-Netty线程模型&epoll-bug问题
Fly_Fly_Zhang的博客
06-13 1528
Proactor&Reactor Proactor和Reactor是两种经典的多路复用IO模型，主要用于在高并发，高吞吐量的环境下进行IO处理。 IO多路复用机制都依赖于事件分发器，事件分发器将客户事件分发到不同的事件处理器中. Select&poll&epoll 在操作系统级别上，select，poll，epoll是三个常用的IO多路复用机制。 三者的具体区别与实现请读...
Java读源码之Netty深入剖析----4.NioEventLoop
羽翼天宇
09-06 391
Java读源码之Netty深入剖析----4.NioEventLoop 分析Netty reactor线程处理过程，包括事件监听，事件处理，常规任务处理和定时任务处理 4-1 NioEventLoop概述 4-2 NioEventLoop创建概述 4-3 ThreadPerTaskThread 4-4 创建NioEventLoop线程 4-5 创建线程选择器 4-6 NioEventLoop...
任务加入线程池是的生效和启动过程详解
之城的专栏
12-16 2864
前言 很早之前我就写过两篇关于线程池的博客, 但是这两篇博客的认识比较浅陋, 有很多需要订正的地方, 所以我决定新开一篇博客. https://blog.csdn.net/leisurelen/article/details/107872827 https://blog.csdn.net/leisurelen/article/details/107872827 在这里我先简单描述下线程池的工作流程 加入一个Task, 如果没有达到核心线程数, 启动一个新Worker执行这个Task 再加入一个Task
netty学习笔记03——利用线程池来处理连接
qq_22343953的博客
05-01 269
文章目录netty学习笔记03——利用线程池来处理连接 netty学习笔记03——利用线程池来处理连接 基于线程池的socket服务器 public class BIOTimeServerThreadPool { public static void main(String[] args){ int port = 8080; if(args!=null && args.l...
Java线程池的使用(简单实现)
weixin_48913290的博客
08-27 1115
创建Java线程需要给线程分配。
Netty-使用业务处理线程池处理业务
weixin_43424751的博客
01-14 2461
Netty-使用业务处理线程池处理业务.md 业务线程是区别与通信线程的另外一种线程的使用类别。 通信线程通常就是用来处理网络I/O相关的各种事件,例如连接操作,消息读取和发送操作。Netty中的NioEventLoop通常就是被用来处理这么一系列的操作。 业务线程通常侧重于处理业务相关的逻辑，在Netty中配置任务处理链的时候可以配置某一个处理器使用特定的处理器实现。 ChannelPipeline addLast(EventExecutorGroup group, ChannelHandler... h
Netty线程池原理
lizc_lizc的博客
01-22 959
Netty线程池原理
Netty中的Option和ChildOption参数解析
男儿当自强
08-18 790
前言 Netty中的Option和ChildOption的区别： 1.Netty中的option主要是设置的ServerChannel的一些选项，而childOption主要是设置的ServerChannel的子Channel的选项。 2.如果是在客户端，因为是Bootstrap，只会有option而没有childOption，所以设置的是客户端Channel的选项。 本文转载自：Netty：option和childOption参数设置说明 一.通用参数 CONNECT_TIMEOUT_MILLIS
Netty 线程模型（Reactor 线程模型）
程序猿进阶
12-14 4151
[Netty 线程模型（Reactor 线程模型） 当说到 Netty 线程模型的时候，一般首先会想到经典的 Reactor 线程模型，尽管不同的 NIO 框架对于 Reactor 模式的实现存在差异，但本质上还是遵循了 Reactor 的基础线程模式。 一、Reactor 单线程模型 无论是C++ 还是 Java 编写的网络框架，大多数都是基于 Reactor 模型进行设计和开发，Reactor 模型基于事件驱动，特别适合海量的 I/O 事件。 【1】Reactor 单线程模型，是指所有的 I/
netty中常见的option、childOption设置
weixin_43785508的博客
03-31 1227
netty中常见的option
netty-socketio 客服
10-28
1. 强大的异步处理能力：Netty-socketio采用事件驱动的方式处理客户端请求，能够高效地处理大量并发连接。 2. 完善的消息传递机制：Netty-socketio提供了灵活的消息传递方式，支持广播、点对点、房间等不同的消息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值