netty 处理耗时任务

原文链接：https://blog.csdn.net/lmq2582609/article/details/89152595
只记录遇到的问题，适用于有Netty基础的小伙伴，如果可以帮到别人那最好，如果有问题，请及时指出。

ByteBuf内存泄漏
handler中如果继承的是ChannelInboundHandlerAdapter类，则需要在重写消息处理channelRead方法中，手动释放ByteBuf，可以在finally块中写上：

ReferenceCountUtil.release(msg);
1
如果继承的是SimpleChannelInboundHandler类，重写channelRead0方法，则不需要，因为这个类继承了ChannelInboundHandlerAdapter类，重写了ChannelRead方法，并帮咱们在finally中释放了ByteBuf。

客户端给服务端发消息注意Channel是否建立成功
客户端connect(IP,PORT)的时候，最好加上监听或者sync()方法，要监听绑定IP或端口是否连接成功，否则如果连接不成功，就发送消息，会导致消息发不出去。

//监听方式
ChannelFuture future = b.connect(HOST,PORT).addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
//监听建立连接成功在发送消息
future.channel().writeAndFlush(JSONObject.toJSONString(“要发送的数据”)+"KaTeX parse error: Expected 'EOF', got '}' at position 22: … }̲ })…_");
1
2
3
4
5
6
7
8
9
10
11
粘包问题处理
我使用的是Netty自带的DelimiterBasedFrameDecoder类来使用特定字符来分隔数据的，这个也是网上看到的，当然客户端和服务端都需要加上这个分隔操作。

bootstrap.childHandler(new ChannelInitializer(){
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//创建分隔符缓冲对象，使用"${}_{"}作为分隔符ByteBufdelimiter=Unpooled.copiedBuffer("$_".getBytes());
ch.pipeline().addLast(new DelimiterBasedFrameDecoder(Integer.MAX_VALUE, delimiter));
//读超时 5秒 写超时 1秒 读写超时 1秒 时间单位：秒
ch.pipeline().addLast(new IdleStateHandler(5,1,1, TimeUnit.SECONDS));
ch.pipeline().addLast(new ServerHeadler());//自定义的headler
ch.pipeline().addLast(new StringEncoder());
}
});
1
2
3
4
5
6
7
8
9
10
11
12
sync()方法
个人理解：它就像synchronized关键字效果一样，只要加上sync()方法，那么它就是同步的，所以如果并发很大，就避免使用sync()方法，除非不影响多线程操作的地方可以使用，否则尽量不要使用，很影响性能。

ctx.close和ctx.channel.close
这两个的区别，ctx.close就是关闭当前上下文的。ctx.channel.close是关闭整个channel。
比如添加了多个handler，然后使用ctx.channel.close，那么它会依次关闭各个handler，然后关闭channel。
比如添加了多个handler，有1、2、3，3个handler，在走到第1个handler，然后使用ctx.close，那么第2个、第3个handler就不会执行了，执行完第1个，就直接关闭channel了。如果走到第二个handler，然后使用ctx.close，那么第1个会执行，第2个会执行，然后就关闭了第3个handler不会执行就关闭了channel了。
这样来看，这两个方法其实差不多，都能达到关闭channel的效果。使用哪个根据自己的业务场景来定。

耗时业务
在服务端的handler中，channelRead0处理消息方法中，采用线程池进行业务处理，从而保证netty自身的线程不被阻塞。
线程池类：

package com.cnpc.Executor;

import java.util.concurrent.*;

/**

• 描述：

• 创建： 一念丶 - LiMingQiang

• 时间： 2019-03-29 13:43
  */
  public class MyExecutor {

  private static volatile Executor executor = null;

  /**

  • 业务线程池
  • @param threadSize 池大小
  • @param queues 队列 - 为0时 设置为20000
  • @return
    */
    public static Executor getBusPool(int threadSize,int queues){
    if(executornull){
    synchronized (MyExecutor.class){
    if(executornull){
    executor = new ThreadPoolExecutor(threadSize, threadSize, 0L, TimeUnit.SECONDS,
    queues == 0 ? new LinkedBlockingQueue<>(5000) : new LinkedBlockingQueue<>(queues),
    new RejectedExecutionHandler() {
    //线程队列拒绝策略
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
    //移除队头元素
    e.getQueue().poll();
    //再尝试入队
    e.execute®;
    }
    }
    });
    }
    }
    }
    return executor;
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    服务端handler采用线程池处理耗时业务：

package com.cnpc.netty;

import com.alibaba.fastjson.JSONObject;
import com.cnpc.Executor.MyExecutor;
import com.cnpc.medium.Media;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import java.nio.charset.Charset;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**

• 描述： NettyServerHandler - 处理消息的headler

•   此headler是每个请求对应一个headler
  

• 创建： 一念丶 - LiMingQiang

• 时间： 2019-03-11 20:54
  */
  public class ServerHeadler extends ChannelInboundHandlerAdapter {

  public static final AtomicLong aid = new AtomicLong(1);

  static{
  //定时任务，每10秒统计一次连接数
  Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() ->{
  System.out.println(“当前连接数：”+aid.get());
  },0,1, TimeUnit.SECONDS);
  }

  private final Executor executor = MyExecutor.getBusPool(500);//500大小，队列5000

  private int lossConnectCount = 0;
  //消息处理
  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg)throws Exception {
  try {
  if(msg instanceof ByteBuf){
  final Object message = msg;
  final ChannelHandlerContext chx = ctx;
  //线程池处理耗时业务
  executor.execute(new Runnable() {
  @Override
  public void run() {
  ByteBuf b = (ByteBuf) message;
  String content = b.toString((Charset.defaultCharset()));
  Thread.sleep(7000);//模拟耗时业务
  ChannelFuture channelFuture = chx.channel().writeAndFlush(JSONObject.toJSONString(“要返回的数据”) + “$_”);
  channelFuture.addListener(new ChannelFutureListener() {
  @Override
  public void operationComplete(ChannelFuture future) throws Exception {
  System.out.println(“ctx：”+chx+“服务端响应完毕”);
  //释放ByteBuf防止内存溢出
  ReferenceCountUtil.release(msg);
  }
  });
  }
  });
  }
  }catch (Exception e){
  // e.printStackTrace();
  }
  }

  @Override
  public void channelActive(ChannelHandlerContext ctx) throws Exception {
  aid.incrementAndGet();//连接进来+1
  }

  @Override
  public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  aid.decrementAndGet();//连接断开-1
  }

  //异常处理
  @Override
  public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)throws Exception {
  System.out.println(this.getClass().getName()+" -> [连接异常] "+ctx.channel().id()+
  “通道异常，异常原因：”+cause.getMessage());
  ctx.close();
  }

  //心跳监测
  @Override
  public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
  if(evt instanceof IdleStateEvent){
  IdleStateEvent event = (IdleStateEvent)evt;
  if(event.state().equals(IdleState.READER_IDLE)){ //如果读通道处于空闲状态，说明没有接收到心跳命令
  lossConnectCount++;
  if (lossConnectCount > 2) {
  // System.out.println("[释放不活跃通道]"+ctx.channel().id());
  ctx.channel().close();
  }
  }
  }else{
  super.userEventTriggered(ctx, evt);
  }
  }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
  100
  101
  高并发option的参数 - 慎用
  区别option和childOption，简单就是说，在服务端程序中，option是针对自己的服务配置（监听socket使用），childOption是客户端连接成功后的channel配置选项（客户端连接后使用）。参数要慎用，知其然知其所以然方可使用，不然很容易就接不到消息，或者发布出去消息。

bootstrap.option(ChannelOption.SO_BACKLOG,4096);//请求的队列的最大长度
bootstrap.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);//重用缓冲区
bootstrap.option(ChannelOption.TCP_NODELAY, true);//立即发送数据
bootstrap.option(ChannelOption.SO_RCVBUF,128);//接收缓冲区大小
bootstrap.option(ChannelOption.SO_SNDBUF,256);//发送缓冲区大小
bootstrap.option(ChannelOption.SO_REUSEADDR,true);//快速端口复用
bootstrap.option(ChannelOption.SO_KEEPALIVE, true);//连接保活
1
2
3
4
5
6
7
有的消息通信成功，有的消息通信失败
若出现这种情况，请注意以下问题。以下为个人遇到问题后梳理，仅供参考。

1、保证有足够的端口可以使用
2、保证有足够的连接数可以使用
3、保证channel的生命周期，确保channel可用
4、注意心跳检测关闭时机，可能出现先关闭后发送的情况，导致服务端发送消息成功，但客户端接收不到消息的情况。
5、大并发情况下，注意对象的创建、代码的编写可靠，尽量避免垃圾创建消耗服务器。
6、最后是服务器带宽上限问题。
————————————————
版权声明：本文为CSDN博主「小太阳〃」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/lmq2582609/article/details/89152595只记录遇到的问题，适用于有Netty基础的小伙伴，如果可以帮到别人那最好，如果有问题，请及时指出。

ByteBuf内存泄漏
handler中如果继承的是ChannelInboundHandlerAdapter类，则需要在重写消息处理channelRead方法中，手动释放ByteBuf，可以在finally块中写上：

ReferenceCountUtil.release(msg);
1
如果继承的是SimpleChannelInboundHandler类，重写channelRead0方法，则不需要，因为这个类继承了ChannelInboundHandlerAdapter类，重写了ChannelRead方法，并帮咱们在finally中释放了ByteBuf。

客户端给服务端发消息注意Channel是否建立成功
客户端connect(IP,PORT)的时候，最好加上监听或者sync()方法，要监听绑定IP或端口是否连接成功，否则如果连接不成功，就发送消息，会导致消息发不出去。

//监听方式
ChannelFuture future = b.connect(HOST,PORT).addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
//监听建立连接成功在发送消息
future.channel().writeAndFlush(JSONObject.toJSONString(“要发送的数据”)+"KaTeX parse error: Expected 'EOF', got '}' at position 22: … }̲ })…_");
1
2
3
4
5
6
7
8
9
10
11
粘包问题处理
我使用的是Netty自带的DelimiterBasedFrameDecoder类来使用特定字符来分隔数据的，这个也是网上看到的，当然客户端和服务端都需要加上这个分隔操作。

bootstrap.childHandler(new ChannelInitializer(){
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//创建分隔符缓冲对象，使用"${}_{"}作为分隔符ByteBufdelimiter=Unpooled.copiedBuffer("$_".getBytes());
ch.pipeline().addLast(new DelimiterBasedFrameDecoder(Integer.MAX_VALUE, delimiter));
//读超时 5秒 写超时 1秒 读写超时 1秒 时间单位：秒
ch.pipeline().addLast(new IdleStateHandler(5,1,1, TimeUnit.SECONDS));
ch.pipeline().addLast(new ServerHeadler());//自定义的headler
ch.pipeline().addLast(new StringEncoder());
}
});
1
2
3
4
5
6
7
8
9
10
11
12
sync()方法
个人理解：它就像synchronized关键字效果一样，只要加上sync()方法，那么它就是同步的，所以如果并发很大，就避免使用sync()方法，除非不影响多线程操作的地方可以使用，否则尽量不要使用，很影响性能。

ctx.close和ctx.channel.close
这两个的区别，ctx.close就是关闭当前上下文的。ctx.channel.close是关闭整个channel。
比如添加了多个handler，然后使用ctx.channel.close，那么它会依次关闭各个handler，然后关闭channel。
比如添加了多个handler，有1、2、3，3个handler，在走到第1个handler，然后使用ctx.close，那么第2个、第3个handler就不会执行了，执行完第1个，就直接关闭channel了。如果走到第二个handler，然后使用ctx.close，那么第1个会执行，第2个会执行，然后就关闭了第3个handler不会执行就关闭了channel了。
这样来看，这两个方法其实差不多，都能达到关闭channel的效果。使用哪个根据自己的业务场景来定。

耗时业务
在服务端的handler中，channelRead0处理消息方法中，采用线程池进行业务处理，从而保证netty自身的线程不被阻塞。
线程池类：

package com.cnpc.Executor;

import java.util.concurrent.*;

/**

• 描述：

• 创建： 一念丶 - LiMingQiang

• 时间： 2019-03-29 13:43
  */
  public class MyExecutor {

  private static volatile Executor executor = null;

  /**

  • 业务线程池
  • @param threadSize 池大小
  • @param queues 队列 - 为0时 设置为20000
  • @return
    */
    public static Executor getBusPool(int threadSize,int queues){
    if(executornull){
    synchronized (MyExecutor.class){
    if(executornull){
    executor = new ThreadPoolExecutor(threadSize, threadSize, 0L, TimeUnit.SECONDS,
    queues == 0 ? new LinkedBlockingQueue<>(5000) : new LinkedBlockingQueue<>(queues),
    new RejectedExecutionHandler() {
    //线程队列拒绝策略
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
    //移除队头元素
    e.getQueue().poll();
    //再尝试入队
    e.execute®;
    }
    }
    });
    }
    }
    }
    return executor;
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    服务端handler采用线程池处理耗时业务：

package com.cnpc.netty;

import com.alibaba.fastjson.JSONObject;
import com.cnpc.Executor.MyExecutor;
import com.cnpc.medium.Media;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import java.nio.charset.Charset;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**

• 描述： NettyServerHandler - 处理消息的headler

•   此headler是每个请求对应一个headler
  

• 创建： 一念丶 - LiMingQiang

• 时间： 2019-03-11 20:54
  */
  public class ServerHeadler extends ChannelInboundHandlerAdapter {

  public static final AtomicLong aid = new AtomicLong(1);

  static{
  //定时任务，每10秒统计一次连接数
  Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() ->{
  System.out.println(“当前连接数：”+aid.get());
  },0,1, TimeUnit.SECONDS);
  }

  private final Executor executor = MyExecutor.getBusPool(500);//500大小，队列5000

  private int lossConnectCount = 0;
  //消息处理
  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg)throws Exception {
  try {
  if(msg instanceof ByteBuf){
  final Object message = msg;
  final ChannelHandlerContext chx = ctx;
  //线程池处理耗时业务
  executor.execute(new Runnable() {
  @Override
  public void run() {
  ByteBuf b = (ByteBuf) message;
  String content = b.toString((Charset.defaultCharset()));
  Thread.sleep(7000);//模拟耗时业务
  ChannelFuture channelFuture = chx.channel().writeAndFlush(JSONObject.toJSONString(“要返回的数据”) + “$_”);
  channelFuture.addListener(new ChannelFutureListener() {
  @Override
  public void operationComplete(ChannelFuture future) throws Exception {
  System.out.println(“ctx：”+chx+“服务端响应完毕”);
  //释放ByteBuf防止内存溢出
  ReferenceCountUtil.release(msg);
  }
  });
  }
  });
  }
  }catch (Exception e){
  // e.printStackTrace();
  }
  }

  @Override
  public void channelActive(ChannelHandlerContext ctx) throws Exception {
  aid.incrementAndGet();//连接进来+1
  }

  @Override
  public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  aid.decrementAndGet();//连接断开-1
  }

  //异常处理
  @Override
  public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)throws Exception {
  System.out.println(this.getClass().getName()+" -> [连接异常] "+ctx.channel().id()+
  “通道异常，异常原因：”+cause.getMessage());
  ctx.close();
  }

  //心跳监测
  @Override
  public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
  if(evt instanceof IdleStateEvent){
  IdleStateEvent event = (IdleStateEvent)evt;
  if(event.state().equals(IdleState.READER_IDLE)){ //如果读通道处于空闲状态，说明没有接收到心跳命令
  lossConnectCount++;
  if (lossConnectCount > 2) {
  // System.out.println("[释放不活跃通道]"+ctx.channel().id());
  ctx.channel().close();
  }
  }
  }else{
  super.userEventTriggered(ctx, evt);
  }
  }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
  100
  101
  高并发option的参数 - 慎用
  区别option和childOption，简单就是说，在服务端程序中，option是针对自己的服务配置（监听socket使用），childOption是客户端连接成功后的channel配置选项（客户端连接后使用）。参数要慎用，知其然知其所以然方可使用，不然很容易就接不到消息，或者发布出去消息。

bootstrap.option(ChannelOption.SO_BACKLOG,4096);//请求的队列的最大长度
bootstrap.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);//重用缓冲区
bootstrap.option(ChannelOption.TCP_NODELAY, true);//立即发送数据
bootstrap.option(ChannelOption.SO_RCVBUF,128);//接收缓冲区大小
bootstrap.option(ChannelOption.SO_SNDBUF,256);//发送缓冲区大小
bootstrap.option(ChannelOption.SO_REUSEADDR,true);//快速端口复用
bootstrap.option(ChannelOption.SO_KEEPALIVE, true);//连接保活
1
2
3
4
5
6
7
有的消息通信成功，有的消息通信失败
若出现这种情况，请注意以下问题。以下为个人遇到问题后梳理，仅供参考。

1、保证有足够的端口可以使用
2、保证有足够的连接数可以使用
3、保证channel的生命周期，确保channel可用
4、注意心跳检测关闭时机，可能出现先关闭后发送的情况，导致服务端发送消息成功，但客户端接收不到消息的情况。
5、大并发情况下，注意对象的创建、代码的编写可靠，尽量避免垃圾创建消耗服务器。
6、最后是服务器带宽上限问题。
————————————————
版权声明：本文为CSDN博主「小太阳〃」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/lmq2582609/article/details/89152595只记录遇到的问题，适用于有Netty基础的小伙伴，如果可以帮到别人那最好，如果有问题，请及时指出。

ByteBuf内存泄漏
handler中如果继承的是ChannelInboundHandlerAdapter类，则需要在重写消息处理channelRead方法中，手动释放ByteBuf，可以在finally块中写上：

ReferenceCountUtil.release(msg);
1
如果继承的是SimpleChannelInboundHandler类，重写channelRead0方法，则不需要，因为这个类继承了ChannelInboundHandlerAdapter类，重写了ChannelRead方法，并帮咱们在finally中释放了ByteBuf。

客户端给服务端发消息注意Channel是否建立成功
客户端connect(IP,PORT)的时候，最好加上监听或者sync()方法，要监听绑定IP或端口是否连接成功，否则如果连接不成功，就发送消息，会导致消息发不出去。

//监听方式
ChannelFuture future = b.connect(HOST,PORT).addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
//监听建立连接成功在发送消息
future.channel().writeAndFlush(JSONObject.toJSONString(“要发送的数据”)+"KaTeX parse error: Expected 'EOF', got '}' at position 22: … }̲ })…_");
1
2
3
4
5
6
7
8
9
10
11
粘包问题处理
我使用的是Netty自带的DelimiterBasedFrameDecoder类来使用特定字符来分隔数据的，这个也是网上看到的，当然客户端和服务端都需要加上这个分隔操作。

bootstrap.childHandler(new ChannelInitializer(){
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//创建分隔符缓冲对象，使用"${}_{"}作为分隔符ByteBufdelimiter=Unpooled.copiedBuffer("$_".getBytes());
ch.pipeline().addLast(new DelimiterBasedFrameDecoder(Integer.MAX_VALUE, delimiter));
//读超时 5秒 写超时 1秒 读写超时 1秒 时间单位：秒
ch.pipeline().addLast(new IdleStateHandler(5,1,1, TimeUnit.SECONDS));
ch.pipeline().addLast(new ServerHeadler());//自定义的headler
ch.pipeline().addLast(new StringEncoder());
}
});
1
2
3
4
5
6
7
8
9
10
11
12
sync()方法
个人理解：它就像synchronized关键字效果一样，只要加上sync()方法，那么它就是同步的，所以如果并发很大，就避免使用sync()方法，除非不影响多线程操作的地方可以使用，否则尽量不要使用，很影响性能。

ctx.close和ctx.channel.close
这两个的区别，ctx.close就是关闭当前上下文的。ctx.channel.close是关闭整个channel。
比如添加了多个handler，然后使用ctx.channel.close，那么它会依次关闭各个handler，然后关闭channel。
比如添加了多个handler，有1、2、3，3个handler，在走到第1个handler，然后使用ctx.close，那么第2个、第3个handler就不会执行了，执行完第1个，就直接关闭channel了。如果走到第二个handler，然后使用ctx.close，那么第1个会执行，第2个会执行，然后就关闭了第3个handler不会执行就关闭了channel了。
这样来看，这两个方法其实差不多，都能达到关闭channel的效果。使用哪个根据自己的业务场景来定。

耗时业务
在服务端的handler中，channelRead0处理消息方法中，采用线程池进行业务处理，从而保证netty自身的线程不被阻塞。
线程池类：

package com.cnpc.Executor;

import java.util.concurrent.*;

/**

• 描述：

• 创建： 一念丶 - LiMingQiang

• 时间： 2019-03-29 13:43
  */
  public class MyExecutor {

  private static volatile Executor executor = null;

  /**

  • 业务线程池
  • @param threadSize 池大小
  • @param queues 队列 - 为0时 设置为20000
  • @return
    */
    public static Executor getBusPool(int threadSize,int queues){
    if(executornull){
    synchronized (MyExecutor.class){
    if(executornull){
    executor = new ThreadPoolExecutor(threadSize, threadSize, 0L, TimeUnit.SECONDS,
    queues == 0 ? new LinkedBlockingQueue<>(5000) : new LinkedBlockingQueue<>(queues),
    new RejectedExecutionHandler() {
    //线程队列拒绝策略
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
    //移除队头元素
    e.getQueue().poll();
    //再尝试入队
    e.execute®;
    }
    }
    });
    }
    }
    }
    return executor;
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    服务端handler采用线程池处理耗时业务：

package com.cnpc.netty;

import com.alibaba.fastjson.JSONObject;
import com.cnpc.Executor.MyExecutor;
import com.cnpc.medium.Media;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import java.nio.charset.Charset;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**

• 描述： NettyServerHandler - 处理消息的headler

•   此headler是每个请求对应一个headler
  

• 创建： 一念丶 - LiMingQiang

• 时间： 2019-03-11 20:54
  */
  public class ServerHeadler extends ChannelInboundHandlerAdapter {

  public static final AtomicLong aid = new AtomicLong(1);

  static{
  //定时任务，每10秒统计一次连接数
  Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() ->{
  System.out.println(“当前连接数：”+aid.get());
  },0,1, TimeUnit.SECONDS);
  }

  private final Executor executor = MyExecutor.getBusPool(500);//500大小，队列5000

  private int lossConnectCount = 0;
  //消息处理
  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg)throws Exception {
  try {
  if(msg instanceof ByteBuf){
  final Object message = msg;
  final ChannelHandlerContext chx = ctx;
  //线程池处理耗时业务
  executor.execute(new Runnable() {
  @Override
  public void run() {
  ByteBuf b = (ByteBuf) message;
  String content = b.toString((Charset.defaultCharset()));
  Thread.sleep(7000);//模拟耗时业务
  ChannelFuture channelFuture = chx.channel().writeAndFlush(JSONObject.toJSONString(“要返回的数据”) + “$_”);
  channelFuture.addListener(new ChannelFutureListener() {
  @Override
  public void operationComplete(ChannelFuture future) throws Exception {
  System.out.println(“ctx：”+chx+“服务端响应完毕”);
  //释放ByteBuf防止内存溢出
  ReferenceCountUtil.release(msg);
  }
  });
  }
  });
  }
  }catch (Exception e){
  // e.printStackTrace();
  }
  }

  @Override
  public void channelActive(ChannelHandlerContext ctx) throws Exception {
  aid.incrementAndGet();//连接进来+1
  }

  @Override
  public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  aid.decrementAndGet();//连接断开-1
  }

  //异常处理
  @Override
  public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)throws Exception {
  System.out.println(this.getClass().getName()+" -> [连接异常] "+ctx.channel().id()+
  “通道异常，异常原因：”+cause.getMessage());
  ctx.close();
  }

  //心跳监测
  @Override
  public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
  if(evt instanceof IdleStateEvent){
  IdleStateEvent event = (IdleStateEvent)evt;
  if(event.state().equals(IdleState.READER_IDLE)){ //如果读通道处于空闲状态，说明没有接收到心跳命令
  lossConnectCount++;
  if (lossConnectCount > 2) {
  // System.out.println("[释放不活跃通道]"+ctx.channel().id());
  ctx.channel().close();
  }
  }
  }else{
  super.userEventTriggered(ctx, evt);
  }
  }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
  100
  101
  高并发option的参数 - 慎用
  区别option和childOption，简单就是说，在服务端程序中，option是针对自己的服务配置（监听socket使用），childOption是客户端连接成功后的channel配置选项（客户端连接后使用）。参数要慎用，知其然知其所以然方可使用，不然很容易就接不到消息，或者发布出去消息。

bootstrap.option(ChannelOption.SO_BACKLOG,4096);//请求的队列的最大长度
bootstrap.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);//重用缓冲区
bootstrap.option(ChannelOption.TCP_NODELAY, true);//立即发送数据
bootstrap.option(ChannelOption.SO_RCVBUF,128);//接收缓冲区大小
bootstrap.option(ChannelOption.SO_SNDBUF,256);//发送缓冲区大小
bootstrap.option(ChannelOption.SO_REUSEADDR,true);//快速端口复用
bootstrap.option(ChannelOption.SO_KEEPALIVE, true);//连接保活
1
2
3
4
5
6
7
有的消息通信成功，有的消息通信失败
若出现这种情况，请注意以下问题。以下为个人遇到问题后梳理，仅供参考。

1、保证有足够的端口可以使用
2、保证有足够的连接数可以使用
3、保证channel的生命周期，确保channel可用
4、注意心跳检测关闭时机，可能出现先关闭后发送的情况，导致服务端发送消息成功，但客户端接收不到消息的情况。
5、大并发情况下，注意对象的创建、代码的编写可靠，尽量避免垃圾创建消耗服务器。
6、最后是服务器带宽上限问题。
————————————————
版权声明：本文为CSDN博主「小太阳〃」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/lmq2582609/article/details/89152595