并发编程设计之Thread-Per-Message模式：最简单实用的分工方法

引言

并发编程领域的问题总结为三个核心问题：分工、同步和互斥。其中，同步和互斥相关问题更多地源自微观，而分工问题则是源自宏观。我们解决问题，往往都是从宏观入手，在编程领域，软件的设计过程也是先从概要设计开始，而后才进行详细设计。同样，解决并发编程问题，首要问题也是解决宏观的分工问题。

并发编程领域里，解决分工问题也有一系列的设计模式，比较常用的主要有 Thread-Per-Message 模式、Worker Thread 模式、生产者 - 消费者模式等等。

如何理解 Thread-Per-Message 模式

比如写一个 HTTP Server，很显然只能在主线程中接收请求，而不能处理 HTTP 请求，因为如果在主线程中处理 HTTP 请求的话，那同一时间只能处理一个请求，太慢了！怎么办呢？可以利用代办的思路，创建一个子线程，委托子线程去处理 HTTP 请求。

这种委托他人办理的方式，在并发编程领域被总结为一种设计模式，叫做Thread-Per-
Message 模式，简言之就是为每个任务分配一个独立的线程。

用 Thread 实现 Thread-Per-Message 模式

Thread-Per-Message 模式的一个最经典的应用场景是网络编程里服务端的实现，服务端
为每个客户端请求创建一个独立的线程，当线程处理完请求后，自动销毁。

网络编程里最简单的程序当数 echo 程序了，echo 程序的服务端会原封不动地将客户端的
请求发送回客户端。例如，客户端发送 TCP 请求"Hello World"，那么服务端也会返回"Hello World"。

final ServerSocketChannel ssc =ServerSocketChannel.open().bind(new InetSocketAddress(8080));
// 处理请求
try {
  while (true) {
  // 接收请求
  SocketChannel sc = ssc.accept();
  // 每个请求都创建一个线程
  new Thread(()->{
    try {
     // 读 Socket
     ByteBuffer rb = ByteBuffer.allocateDirect(1024);
     sc.read(rb);
     // 模拟处理请求
     Thread.sleep(2000);
     // 写 Socket
     ByteBuffer wb = (ByteBuffer)rb.flip();
     sc.write(wb);
     // 关闭 Socket
     sc.close();
    }catch(Exception e){
     throw new UncheckedIOException(e);
    }
  }).start();
}
} finally {
  ssc.close();
}

Java 中的线程是一个重量级的对象，创建成本很高，一方面创建线程比较耗时，另一方面线程占用的内存也比较大。所以，为每个请求创建一个新的线程并不适合高并发场景。

你开始质疑 Thread-Per-Message 模式，而且开始重新思索解决方案，这时候很可能你会想到 Java 提供的线程池。你的这个思路没有问题，但是引入线程池难免会增加复杂度。其实你完全可以换一个角度来思考这个问题，语言、工具、框架本身应该是帮助我们更敏捷地实现方案的，而不是用来否定方案的，Thread-Per-Message 模式作为一种最简单的分工方案，Java 语言支持不了，显然是 Java 语言本身的问题。

Java 语言里，Java 线程是和操作系统线程一一对应的，这种做法本质上是将 Java 线程的调度权完全委托给操作系统，而操作系统在这方面非常成熟，所以这种做法的好处是稳定、可靠，但是也继承了操作系统线程的缺点：创建成本高。为了解决这个缺点，Java 并发包里提供了线程池等工具类。

业界还有另外一种方案，叫做轻量级线程。这个方案在 Java 领域知名度并不高，但是在其他编程语言里却叫得很响，例如 Go 语言、Lua 语言里的协程，本质上就是一种轻量级的线程。轻量级的线程，创建的成本很低，基本上和创建一个普通对象的成本相似；并且创建的速度和内存占用相比操作系统线程至少有一个数量级的提升。

总结：
觉得有用的客官可以点赞、关注下！感谢支持🙏谢谢!