Netty与protobuf，线程池的使用

已于 2023-04-20 11:25:16 修改
阅读量461 收藏 2
点赞数
文章标签： java 服务器 开发语言
于 2023-04-20 10:51:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47748260/article/details/130247912
版权
本文介绍了如何使用Netty构建服务器和客户端，以及结合Google的protobuf工具库进行数据传输。客户端发送包含uid和index字段的protobuf数据，服务器解析并打印。通过线程池，服务器能并行处理1000个数据包，确保同一UID的数据在同一时间仅占用一个线程。
摘要由CSDN通过智能技术生成

Netty

本文主要是介绍 Netty与protobuf，线程池的使用。主要是围绕一下几个问题进行介绍

  1. 使用Netty搭建一个服务器。
  2. 使用Netty搭建一个客户端。
  3. 客户端发送字符串，服务器端打印。
  4. 了解google的protobuf工具库。
  5. 客户端使用protobuf发送一个数据，包含两个字段：uid=10以内的随机，index=自增长整数。
  6. 服务器解析出这个数据包并打印内容。
  7. 客户端同时发送1000个包含上述两个字段的随机数据的数据包，服务器能成功接收并打印。
  8. 服务器使用线程池，可以并行的处理这1000条数据。
  9. 保证同一个UID的数据同时只占用一个线程。

Netty与protobuf，线程池的使用

首先，需要在项目的依赖中添加Netty和protobuf库。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>netty_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.25.Final</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.6.1</version>
        </dependency>
    </dependencies>

</project>

搭建服务器端

使用Netty搭建服务器端，需要实现以下步骤：

  1. 创建 EventLoopGroup 对象，用于管理NIO线程
  2. 创建 ServerBootstrap 对象，用于启动服务端
  3. 配置事件处理器 ChannelInitializer
  4. 启动服务端，并绑定端口
import com.bo.netty.handler.*;
import com.bo.netty.protobuf.UserPOJO;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.protobuf.ProtobufDecoder;


public class NettyServer {

    public static void main(String[] args) {
        // 用于接收客户端连接的线程工作组
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        // 用于对接收客户端连接读写操作的线程工作中
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 服务端启动器
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup) // 绑定两个工作线程组
                    .channel(NioServerSocketChannel.class) // 设置NIO的模型
                    .option(ChannelOption.SO_BACKLOG, 1024) // 设置tcp缓冲区大小
                    .option(ChannelOption.SO_RCVBUF, 32 * 1024) // 设置发送数据的缓冲大小
                    .childOption(ChannelOption.SO_KEEPALIVE, Boolean.TRUE)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            // 为通道进行初始化 数据传输过来的时候会进行拦截和执行
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new NettyServerHandler());
                        }
                    });

            System.out.println("服务器启动，端口：9090");
            // 绑定端口启动
            ChannelFuture sync = serverBootstrap.bind(9090).sync();
            // 释放
            sync.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 接收客户端的线程组进行释放
            bossGroup.shutdownGracefully();
            // 用于处理客户端读取的线程组进行释放
            workerGroup.shutdownGracefully();
        }
    }
}

NettyServerHandler

NettyServerHandler 是自定义的事件处理器，用于处理接受到的消息。同时还添加了字符串的解码和编码器。

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;

/**
 * 服务端处理通道.这里只是打印一下请求的内容，并不对请求进行任何的响应 DiscardServerHandler 继承自
 * ChannelHandlerAdapter， 这个类实现了ChannelHandler接口， ChannelHandler提供了许多事件处理的接口方法，
 * 然后你可以覆盖这些方法。 现在仅仅只需要继承ChannelHandlerAdapter类而不是你自己去实现接口方法。
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 这里我们覆盖了chanelRead()事件处理方法。 每当从客户端收到新的数据时， 这个方法会在收到消息时被调用，
     * 这个例子中，收到的消息的类型是ByteBuf
     *
     * @param ctx 通道处理的上下文信息
     * @param msg 接收的消息
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            ByteBuf in = (ByteBuf) msg;
            // 打印客户端输入，传过来的字符
            System.out.println(in.toString(CharsetUtil.UTF_8));
        } catch (Exception e) {

        } finally {
            ReferenceCountUtil.release(msg);
        }
    }

    /***
     * 这个方法会在发生异常时触发
     * exceptionCaught() 事件处理方法是当出现 Throwable 对象才会被调用，即当 Netty 由于 IO
     * 错误或者处理器在处理事件时抛出的异常时。在大部分情况下，捕获的异常应该被记录下来 并且把关联的 channel
     * 给关闭掉。然而这个方法的处理方式会在遇到不同异常的情况下有不 同的实现，
     * 比如你可能想在关闭连接之前发送一个错误码的响应消息。
     * @param ctx
     * @param cause
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        // 出现异常就关闭
        ctx.close();
    }

}

搭建客户端

使用Netty搭建客户端，需要实现以下步骤：

  1. 创建 EventLoopGroup 对象，用于管理NIO线程
  2. 创建 Bootstrap 对象，用于启动客户端
  3. 配置事件处理器 ChannelInitializer
  4. 启动客户端，并连接服务器
EventLoopGroup workerGroup = new NioEventLoopGroup();

import com.bo.netty.handler.NettyClientHandler;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.protobuf.ProtobufEncoder;


public class NettyClient {

    public static void main(String[] args) throws Exception {
        // 线程工作组
        NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
        // 客户端启动类
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(eventExecutors)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch)  {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast(new ProtobufEncoder());
                        pipeline.addLast(new NettyClientHandler());
                    }
                });
        try {
            System.out.println("客户端启动，端口：9090");
            ChannelFuture sync = bootstrap.connect("127.0.0.1",9090).sync();
            sync.channel().closeFuture().sync();
        } finally {
            eventExecutors.shutdownGracefully();
        }
    }
}

NettyClientHandler

NettyClientHandler 是自定义的事件处理器，用于处理接受到的消息。同时还添加了字符串的解码和编码器。

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
       String message = "Hello, World!";
		ctx.writeAndFlush(message);
    }

    /**
     * 当通道有数据的的是会触发
     *
     * @param ctx 上下文对象，管道pipeline 通道 channel 地址
     * @param msg 消息
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("服务器回复的消息：" + byteBuf.toString(CharsetUtil.UTF_8));
        for (int i = 0; i < 1000; i++) {
            ctx.writeAndFlush("你好");
            super.channelActive(ctx);
        }
    }
}

发送字符串

在客户端发送一个字符串后，服务端可以直接打印出来，因为服务器已经添加了相应的解码器和事件处理器。

String message = "Hello, World!";
ctx.writeAndFlush(message);

使用protobuf

使用protobuf需要先定义好数据协议，然后生成Java类，在代码中使用这些类就可以了。

首先，定义数据协议文件 User.proto ：

syntax = "proto3";

option java_outer_classname = "UserPOJO";

message user {
  int32 uid = 1;
  int32 index = 2;
}

使用protobuf插件生成Java类：

protoc --java_out=./ User.proto

生成的Java类：com.bo.netty.protobuf.UserPOJO 和 com.bo.netty.protobuf.UserPOJO.user

在客户端和服务器端都需要添加protobuf的编码器和解码器，并且使用 com.bo.netty.protobuf..UserPOJO 类型的对象作为消息的数据类型。

客户端发送一个protobuf消息

NettyClientHandler 是自定义的事件处理器，用于处理接受到的消息。同时还添加了字符串的解码和编码器。

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    /**
     * 当通道就绪的时候会触发
     *
     * @param ctx 上下文对象，管道pipeline 通道 channel 地址
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        UserPOJO.user user = UserPOJO.user.newBuilder().setUid(new Random().nextInt(10)).setIndex(new Random().nextInt(10)).build();
        ctx.writeAndFlush(user);
        super.channelActive(ctx);
    }

    /**
     * 当通道有数据的的是会触发
     *
     * @param ctx 上下文对象，管道pipeline 通道 channel 地址
     * @param msg 消息
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("服务器回复的消息：" + byteBuf.toString(CharsetUtil.UTF_8));
        UserPOJO.user user = UserPOJO.user.newBuilder().setUid(new Random().nextInt(10)).setIndex(new Random().nextInt(10)).build();
        ctx.writeAndFlush(user);
        super.channelRead(ctx, msg);
    }
}

服务端接收并处理protobuf消息

NettyServer protobuf数据 设置编码格式

public void start() {
        // 用于接收客户端连接的线程工作组
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        // 用于对接收客户端连接读写操作的线程工作中
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 服务端启动器
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup) // 绑定两个工作线程组
                    .channel(NioServerSocketChannel.class) // 设置NIO的模型
                    .option(ChannelOption.SO_BACKLOG, 1024) // 设置tcp缓冲区大小
                    .option(ChannelOption.SO_RCVBUF, 32 * 1024) // 设置发送数据的缓冲大小
                    .childOption(ChannelOption.SO_KEEPALIVE, Boolean.TRUE)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            // 为通道进行初始化 数据传输过来的时候会进行拦截和执行
                            ChannelPipeline pipeline = ch.pipeline();
                            // protobuf数据 设置编码格式
                            pipeline.addLast(new ProtobufDecoder(UserPOJO.user.getDefaultInstance()));
                            pipeline.addLast(new NettyServerHandler());
                        }
                    });

            System.out.println("服务器启动，端口：9090");
            // 绑定端口启动
            ChannelFuture sync = serverBootstrap.bind(9090).sync();
            NettyServerHandler_6.runConsumer();
            // 释放
            sync.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 接收客户端的线程组进行释放
            bossGroup.shutdownGracefully();
            // 用于处理客户端读取的线程组进行释放
            workerGroup.shutdownGracefully();
        }
    }

NettyClientHandler 是自定义的事件处理器

import com.bo.netty.protobuf.UserPOJO;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;


public class NettyServerHandler extends SimpleChannelInboundHandler<UserPOJO.user> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, UserPOJO.user user) {
        System.out.println("uid: " + user.getUid() + "index: " + user.getIndex());
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello，客户端", CharsetUtil.UTF_8));
    }


    /***
     * 这个方法会在发生异常时触发
     * exceptionCaught() 事件处理方法是当出现 Throwable 对象才会被调用，即当 Netty 由于 IO
     * 错误或者处理器在处理事件时抛出的异常时。在大部分情况下，捕获的异常应该被记录下来 并且把关联的 channel
     * 给关闭掉。然而这个方法的处理方式会在遇到不同异常的情况下有不 同的实现，
     * 比如你可能想在关闭连接之前发送一个错误码的响应消息。
     * @param ctx
     * @param cause
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        // 出现异常就关闭
        ctx.close();
    }
}

线程池处理数据

这里使用了线程池 executorService 来并行处理1000条数据

客户端发送数据

NettyClientHandler 发送1000条数据

import com.bo.netty.protobuf.UserPOJO;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;


public class NettyClientHandler extends ChannelInboundHandlerAdapter {

   AtomicInteger atomicInteger = new AtomicInteger(0);


   /**
    * 当通道就绪的时候会触发
    *
    * @param ctx 上下文对象，管道pipeline 通道 channel 地址
    * @throws Exception
    */
   @Override
   public void channelActive(ChannelHandlerContext ctx) throws Exception {
       atomicInteger.compareAndSet(atomicInteger.get(),
               atomicInteger.get() + 1);
       UserPOJO.user user = UserPOJO.user.newBuilder().setUid(new Random().nextInt(10)).setIndex(atomicInteger.get()).build();
       ctx.writeAndFlush(user);
       super.channelActive(ctx);
   }

   /**
    * 当通道有数据的的是会触发
    *
    * @param ctx 上下文对象，管道pipeline 通道 channel 地址
    * @param msg 消息
    * @throws Exception
    */
   @Override
   public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
       ByteBuf byteBuf = (ByteBuf) msg;
       System.out.println("服务器回复的消息：" + byteBuf.toString(CharsetUtil.UTF_8));
       if (atomicInteger.get() < 1000) {
           atomicInteger.compareAndSet(atomicInteger.get(),
                   atomicInteger.get() + 1);
           UserPOJO.user user = UserPOJO.user.newBuilder().setUid(new Random().nextInt(10)).setIndex(atomicInteger.get()).build();
           ctx.writeAndFlush(user);
       }
       super.channelRead(ctx, msg);
   }
}

服务端处理数据

NettyServerHandler 处理数据

public class NettyServerHandler extends SimpleChannelInboundHandler<UserPOJO.user> {

   private static final ExecutorService THREAD_POOL = Executors.newFixedThreadPool(10);

   @Override
   protected void channelRead0(ChannelHandlerContext ctx, UserPOJO.user user) {
       THREAD_POOL.execute(() -> {
           try {
               // 模拟业务处理时间
               Thread.sleep(ThreadLocalRandom.current().nextInt(1000));
           } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
           }
           System.out.println(Thread.currentThread().getName() + "正在执行：[" + user.getUid() + "] 用户的第[" + user.getIndex() + "]任务");
           ctx.writeAndFlush(Unpooled.copiedBuffer(Thread.currentThread().getName() + " 发送：hello，客户端", CharsetUtil.UTF_8));

       });
   }


   /***
    * 这个方法会在发生异常时触发
    * exceptionCaught() 事件处理方法是当出现 Throwable 对象才会被调用，即当 Netty 由于 IO
    * 错误或者处理器在处理事件时抛出的异常时。在大部分情况下，捕获的异常应该被记录下来 并且把关联的 channel
    * 给关闭掉。然而这个方法的处理方式会在遇到不同异常的情况下有不 同的实现，
    * 比如你可能想在关闭连接之前发送一个错误码的响应消息。
    * @param ctx
    * @param cause
    */
   @Override
   public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
       cause.printStackTrace();
       // 出现异常就关闭
       ctx.close();
   }
}

保证同一个UID的数据同时只占用一个线程

NettyServerHandler 处理数据时候 保证同一个UID的数据同时只占用一个线程，采用阻塞消费的思想来实现

import com.bo.netty.protobuf.UserDTO;
import com.bo.netty.protobuf.UserPOJO;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

import java.util.concurrent.*;


public class NettyServerHandler_6 extends SimpleChannelInboundHandler<UserPOJO.user> {

   private static final ExecutorService THREAD_POOL = Executors.newFixedThreadPool(10);

   // QUEUE_MAP
   private static ConcurrentHashMap<Integer, BlockingQueue<UserDTO>> QUEUE_MAP = new ConcurrentHashMap<>();

   static {
       QUEUE_MAP.put(0, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(1, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(2, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(3, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(4, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(5, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(6, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(7, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(8, new LinkedBlockingQueue<>());
       QUEUE_MAP.put(9, new LinkedBlockingQueue<>());
   }


   @Override
   protected void channelRead0(ChannelHandlerContext ctx, UserPOJO.user msg) throws Exception {
       int uid = msg.getUid();
       BlockingQueue<UserDTO> userBlockingQueue = QUEUE_MAP.computeIfAbsent(uid, k -> new LinkedBlockingQueue<>());
       UserDTO userDTO = new UserDTO();
       userDTO.setUser(msg);
       userDTO.setCtx(ctx);
       userBlockingQueue.add(userDTO);
   }

   /**
    * 消费者
    */
   public static void runConsumer() {
       QUEUE_MAP.forEach((key, value) -> {
           THREAD_POOL.execute(new Consumer(value));
       });
   }


   static class Consumer implements Runnable {
       private final BlockingQueue<UserDTO> queue;
       public Consumer(BlockingQueue<UserDTO> queue) {
           this.queue = queue;
       }
       @Override
       public void run() {
           try {
               // 阻塞消费
               while (true) {
                   UserDTO num = queue.take();
                   consume(num);
               }
           } catch (Exception e) {
               e.printStackTrace();
           }
       }

       private void consume(UserDTO userDTO) throws Exception {
           // 处理该UID的所有数据包的逻辑
           ChannelHandlerContext ctx = userDTO.getCtx();
           UserPOJO.user user = userDTO.getUser();
           // 模拟业务处理时间
           Thread.sleep(ThreadLocalRandom.current().nextInt(1000));
           // 消费数据的代码
           System.out.println(Thread.currentThread().getName() + "正在执行：[" + user.getUid() + "] 用户的第[" + user.getIndex() + "]任务");
           ctx.writeAndFlush(Unpooled.copiedBuffer(Thread.currentThread().getName() + " 发送：hello，客户端", CharsetUtil.UTF_8));
       }
   }
}

需要注意下：在启动服务端的时候也要启动消费线程

end~，有更好的解决方法欢迎交流呦！！！

总以為.
关注
Netty-使用线程池优化BIO-代码实现
CodeDabaicai的博客
01-27 385
1、背景介绍 已知NIO的性质是每有一个新的连接请求就要新建一个线程与之连接，线程的创建对资源的消耗是很大的，可以使用之前学过的池化思想来节省线程资源 2、设计要求 使用BIO模型食记一个服务器端，监听某个端口，当有客户端请求连接时就启动一个线程与之通讯，服务器端可以接收服务器发生的数据 3、代码实现 代码分为两部分，第一部分是main函数，第二部分是handler函数，需要注意是是涉及到Socke和输入流的一些Java知识点 package BIO; import java.io.IOExceptio
netty使用protobuf和心跳检查、断线重连
zsj777的专栏
10-22 512
1、下载安装protoc，本人使用3.6.1版本 https://github.com/protocolbuffers/protobuf/releases 下载protoc，选择对应的操作系统 2、user.proto文件内容如下 syntax ="proto3"; // 生成的包名 option java_package="com.pancm.protobuf"; //生成的j...
Netty线程池原理
lizc_lizc的博客
01-22 1008
Netty线程池原理
netty之Netty使用Protobuf传输数据
最新发布
CSDN_LiMingfly的博客
10-03 465
在netty数据传输过程中可以有很多选择，比如；字符串、json、xml、java对象，但为了保证传输的数据具备；良好的通用性、方便的操作性和传输的高性能，我们可以选择protobuf作为我们的数据传输格式。目前protobuf可以支持；C++、C#、Dart、Go、Java、Python等，也可以在JS里使用。知识点；@Override//protobuf 处理// 在管道中添加我们自己的接收数据实现方法/*** 当客户端主动链接服务端的链接后，这个通道就是活跃的了。
Netty 线程池
热门推荐
炫的博客
08-09 2万+
Netty的线程池有什么样的特性 Java 原生线程池 Java 原生的线程池主要有三种：ThreadPoolExecutor、ScheduledThreadPoolExecutor、ForkJoinPool。 ThreadPoolExecutor 是最古老的类，我们通常说的线程池，也是指这个类。 ScheduledThreadPoolExecutor 是用来执行定时任务的线程池。 ForkJoinPool 是 Java7 新增的类，它使用的是工作窃取的算法实现的一种高效的线程池，非常适合解决大任务不断地
netty+Protobuf (整合二）
架构师尼恩
11-09 494
Protobuf 消息设计方法 疯狂创客圈 死磕Netty 系列之12 【博客园 总入口 】 本文说明 本篇是 netty+Protobuf 实战的第二篇，完成一个 基于Netty + Protobuf 实战案例。 本篇简单说明一下，实例中，设计Protobuf 消息的大致原则和思路。 消息的大致类型 网络通信涉及到消息的定义，不管是直接使用二进制格式，还是 xml、json等字符串格式。消息都...
netty+Protobuf （整合一）
weixin_34388207的博客
11-09 293
netty+Protobuf 整合实战疯狂创客圈 死磕Netty 亿级流量架构系列之12 【博客园 总入口 】本文说明本篇是 netty+Protobuf 整合实战的 第一篇，完成一个 基于Netty + Protobuf 实战案例。要实现高并发、大流量，首先需要高传输效率的协议，Protobuf 是迄今为止最高性能之一的传输格式，我们首先将 Protobuf 和Netty整合起来。本案例源代码源...
netty的线程池(揭示了使用两个线程池的原因)&知识汇总
m0_45406092的博客
12-31 3225
线程模型是Netty的核心设计，设计地很巧妙，之前项目中有一块处理并发的设计和Netty的Eventloop单线程设计类似，效果得到了实证。 Netty5的类层次结构和之前的版本变化很大，网上也有很多文章写Netty的线程模型，Reactor模式，比如这篇http://blog.csdn.net/xiaolang85/article/details/37873059， 应该是引自《Netty权威指南》，写得比较全面，但是有几个关键的概念没讲清楚。 这篇文章只讲Netty5线程模型最重要的几个关键点 理解Ni
netty+protobuf开发一个聊天室实例
06-18
在本文中，我们将深入探讨如何使用Netty和Protobuf来开发一个实时聊天室实例。Netty是一个高性能、异步事件驱动的网络应用框架，适用于Java平台，它简化了TCP、UDP和HTTP等协议的服务器和客户端应用开发。而Protobuf...
基于netty和protobuf的聊天系统，客户端+服务器
01-06
3. **Netty客户端**：客户端代码负责与服务器建立连接，发送protobuf编码的消息，并接收并解码服务器返回的消息，展示给用户。 4. **事件驱动模型**：Netty使用事件驱动模型，通过ChannelHandlerContext处理网络...
netty4 protobuf3多类型传输实现
zsj777的专栏
10-23 567
做后台服务经常有这样的流程: 如何优雅的完成这个过程呢？ 首先要解决的是如何在netty+protobuf中传输多个protobuf协议，这里采取的方案是使用一个类来做为描述协议的方案，也就是需要二次解码的方案，IDL文件如下: syntax = "proto3"; option java_package = "com.nonpool.proto"; // 生成的时候设置java_mu...
netty+protobuf （整合源代码）
11-09
来自于疯狂创客圈 《netty+protobuf 整合实战》的源代码，付上了 protobuf 的 protoc 工具， protoc-2.6.1-win32.zip
Netty4+ProtoBuf通信框架
07-27
客户端与服务端通信，协议用protoBuf。maven项目，其中有startClient与startServer两个mainClass。不懂的可以留言
Netty对Protobuf的解决粘包/半包问题的编解码方案
07-04 6344
protobuf编解码内置方案 解码工具类：ProtobufDecoder+ProtobufVarint32FrameDecoder 编码工具类：ProtobufEncoder+ProtobufVarint32LengthFieldPrepender 原理 代码： 1.user.proto syntax="proto2"; package netty.protobuf; option j...
Netty Protobuf
hn_lzh2014的博客
03-24 611
RPC[远程过程调用 remote procedure call]支持目前绝大多数语言。， 然后配置环境变量。
解密netty是怎么玩线程池
Angus
06-27 760
netty如此强大和优秀的通信框架，是如何封装和使用线程池的。 其实这一点我是非常的好奇，我们在使用netty的时候，似乎没有感受到哪里有线程池相关的操作。 这篇文章解密netty使用线程池的精妙绝伦的地方。 netty中和线程池相关的东西 我截取了一份netty服务端的代码，如下： 上图中的EventLoopGroup实际上就是线程池，只不过netty是基于事件驱动的，它想要把一切都描述的和事件相关，所以它给线程池套上了一个事件马甲，然后叫做 “事件循...
Netty5源码分析（二） -- 线程模型分析
ITer_ZC的专栏
09-18 6101
线程模型是Netty的核心设计，设计地很巧妙，之前项目中有一块处理并发的设计和Netty的Eventloop单线程设计类似，效果得到了实证。 Netty5的类层次结构和之前的版本变化很大，网上也有很多文章写Netty的线程模型，Reactor模式，比如这篇http://blog.csdn.net/xiaolang85/article/details/37873059， 应该是引自《Net
netty+Protobuf
NRGAGA的专栏
04-28 866
https://www.jianshu.com/p/6102cc52b8fe http://www.cnblogs.com/crazymakercircle/p/9937738.html
Netty编解码方案之Protobuf介绍，Java工作经验6年
m0_55030688的博客
03-29 786
这些面试题是我朋友进阿里前狂刷七遍以上的面试资料，由于面试文档很多，内容更多，没有办法一一为大家展示出来，所以只好为大家节选出来了一部分供大家参考。面试的本质不是考试，而是告诉面试官你会做什么，所以，这些面试资料中提到的技术也是要学会的，不然稍微改动一下你就凉凉了。
简易RPC框架：Nacos、Netty与Protobuf的融合实践
资源摘要信息: "一个基于Nacos、Netty、Protobuf 实现的简单易懂的RPC框架" 在深入分析该资源之前，有必要先对标题中提及的关键技术Nacos、Netty、Protobuf和RPC框架进行概念上的阐释，以便更好地理解资源内容。 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值