Netty-阻止操作在完成之前不接受客户端请求

Question

[问题]：我有一个Netty Server，它将通过TCP侦听客户端，并处理请求并发回响应。 问题在于处理部分需要时间，因为它需要应用程序用户的验证。 客户端一个接一个地发送多个请求，并且服务器似乎直到上一个请求完成才接受该客户端的请求。

我已经复制了一个场景，客户端将一个接一个地发送几个请求，而服务器将花费一些时间来处理请求和处理。 通过将阻塞操作传递给另一个线程并完成剩余的操作，我可以很好地处理单个请求阻塞请求。 但这仍然不接受来自客户端的第二个请求，它仍将等待阻塞操作完成，然后再接受来自客户端的另一个请求。

客户代码

int count =0;
long currentTime = System.currentTimeMillis();
long trigger = currentTime + 5000;
long stop_loop = currentTime + 130000;
while(count<2){
  boolean loop = true;
  while(loop){
    if(System.currentTimeMillis()>trigger){
      trigger += 5000;
      count++;
      loop = false;
    }
  }
  System.out.println("SENDING FOR COUNTER - "+count);
  content = Unpooled.copiedBuffer(b);
  System.out.println("Channel Active Method Called: "+ctx);
  ctx.write(content);
  ctx.flush();
}

服务器代码：

public void channelRead(ChannelHandlerContext ctx, Object msg) { 
final ExecutorService blockingThreadPool = Executors.newFixedThreadPool(10);
  try {
  System.out.println("server receive orde:"+body+"the counter is:" + ++counter);
  ctx.executor().execute(new Runnable(){
     public void run(){
        try{
            new MyBusinessLogicHandler(blockingThreadPool).channelRead(ctx , b_buf);
        }
        catch(Exception e ){
           logger.error(e.getMessage());
        }
     }
  }
  //ByteBuf resp = Unpooled.copiedBuffer(currentTime,CharsetUtil.UTF_8);
  //ByteBuf resp = Unpooled.wrappedBuffer(response.getBytes());
  //ctx.writeAndFlush(resp);
 // ctx.write(resp);
  //ctx.flush();
}

我的业务逻辑

 @Override
    public void channelRead(ChannelHandlerContext ctx, Object arg1)
                throws Exception{
         System.out.println(" INSIDE BUSINESS HANDLER - OBJ");
         System.out.println(arg1);

         String x = ctx.channel().attr(DiscardServerHandler.CHECKSUMKEY).get();
         System.out.println("X -"+x);

         ChannelHandlerContext temp = ctx;

         resp = Unpooled.wrappedBuffer(x.getBytes());
         ctx.write(resp);
         ctx.flush();
         ByteBuf buf = (ByteBuf) arg1;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req,CharsetUtil.UTF_8);
            System.out.println(new Date());
            System.out.println("Business logic receive order : " + body);

            System.out.println("SERVER LISTENER READ");
            boolean loop = true;
            long currentTime = System.currentTimeMillis();
            long trigger = currentTime + 3000;
            long stop_loop = currentTime + 20000;
            int count = 0;
                System.out.println("Server READ");
//              String response = "Server Complete Response ";

                while(loop){
                    long now = System.currentTimeMillis();

                    if(now<stop_loop){

                        if(now>trigger){
                            count++;
                            System.out.println("Now is triggered @" + count + "-- "+(count*5)+"secs passed");
                            trigger += 5000;
                        }

                    }
                    else if(now>stop_loop){
                        loop = false;
                        System.out.println("Loop Completes");
                    }
                }
            String re = "BUSINESS LOGIC RESPONSE";  
            resp = Unpooled.wrappedBuffer(re.getBytes());

            temp.write(resp);
            temp.flush();

     }

我想要的是接受所有客户端请求，无论它们之前有无完成/不完整的请求。

Answer 1

这是经典模式，您需要从同步服务切换到异步（“异步”）服务。 异步服务的想法是，您从客户端接收请求，然后验证该请求并将其存储在“待办事项”列表中服务器的某些存储中（通常是队列中）。 然后您返回响应（在这种情况下，称为确认（“ ack”））。 在您的回复中，您向客户返回其请求的ID和返回答案的媒介。 （通常是一个队列）。 因此，客户端将知道在哪里收听结果。 同时，您现在可以在服务器上处理收到的请求，而无需阻止客户端。 您还可以有多个“工作者”实例，这些实例从您的存储中接收传入的请求并进行处理。 处理完请求后，您的工作进程会以您在“ ack”中返回给客户端的相同ID将其发布到您在“ ack”中返回给客户端的媒介（队列）中。 有关更多信息，请参见此处： 异步执行与同步执行，这实际上意味着什么？