前言

正文

介绍

可以当做 Worker Thread 模式的改进版，一个任务一个线程，但是当任务结束后，并不销毁线程，而是等待下一个任务

优点&缺点

优点：线程复用，避免重复创建线程造成的资源消耗
缺点：不灵活，不会随着任务数的增加而增加线程数量，也不会随着任务数量的减少而减少线程数量

实现

对Thread-Per-Message进行改进，用阻塞队列保存任务，当有任务时，线程领取任务进行执行，当没有任务时，线程等待

  1. public class WorkerThreadTest {
  2.     private final BlockingQueue<Runnable> works;
  3.     public WorkerThreadTest(BlockingQueue _works,int _threadNum){
  4.         this.works = _works;
  5.         for (int i = 0; i < _threadNum; i++) {
  6.             new Thread(()->{
  7.                 //使线程一直运行，阻止线程销毁
  8.                 while(true){
  9.                     synchronized(this){
  10.                         if(!works.isEmpty()){
  11.                             works.poll().run();
  12.                         }
  13.                     }
  14.                 }
  15.             }).start();
  16.         }
  17.     }
  18.     public void execute(Runnable work){
  19.         if(null == work){
  20.             throw new NullPointerException("任务不可以为 null");
  21.         }
  22.         works.add(work);
  23.     }
  24. }
  1. public class Client {
  2.     public static void main(String[] args) {
  3.         //设置任务阻塞队列
  4.         LinkedBlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(8);
  5.         //设置线程数为 6
  6.         WorkerThreadTest wt = new WorkerThreadTest(workQueue,6);
  7.         wt.execute(new Runnable() {
  8.             @Override
  9.             public void run() {
  10.                 System.out.println("hello world");
  11.             }
  12.         });
  13.     }
  14. }