今天看了线程池的源码，实现了一下线程池的思想。（第一次写的时候还死锁了···）
    其实线程池最大的问题在于，如何让线程一直活着。毕竟线程执行完run方法就会变成终止态。如果不能一直活着，也就无法池化了。
    解决线程一直活着的方法就是让线程在run方法中不断访问父作用域的阻塞队列获取任务。阻塞队列中的阻塞方法帮助线程阻塞，延长它的寿命。

    1. public class MyThreadPool {
    3.     class Worker implements Runnable{
    4.         private Runnable task;
    5.         private Thread thread;
    8.         public Worker() {
    9.             this.task = null;    
    10.             //这里一开始死锁了
    11.         }
    13.         @Override
    14.         public void run() {
    15.             work(this);
    16.         }
    17.     }
    19.     private void work(Worker worker) {
    20.         while (true) {
    21.             try {
    22.                 if (worker.task == null) {
    23.                     worker.task = works.take();
    24.                     worker.task.run();
    25.                     worker.task = null;
    26.                 }
    27.             } catch (InterruptedException e) {
    28.                 e.printStackTrace();
    29.             }
    30.         }
    31.     }
    33.     private final BlockingQueue<Runnable> works;
    34.     private final HashSet<Worker> workers;
    36.     public MyThreadPool(){
    37.         works = new ArrayBlockingQueue<>(10);
    38.         workers = new HashSet<>();
    39.         for (int i=0; i<5; i++) {
    40.             Worker worker = new Worker();
    41.             Thread t = new Thread(worker);
    42.             worker.thread = t;
    43.             t.start();
    44.         }
    45.     }
    47.     public void execute(Runnable runnable) {
    48.         works.offer(runnable);
    49.     }
    51. //    public static MyThreadPool getSingleton() {
    52. //        return singleton;
    53. //    }
    55. //    private static final MyThreadPool singleton = new MyThreadPool();
    57.     public static void main(String[] args) {
    58.         MyThreadPool pool = new MyThreadPool();
    59.         try {
    60.             while (true) {
    61.                 pool.execute(() -> {
    62.                     try {
    63.                         System.out.println(Thread.currentThread().getName() + "在干活，花费一秒");
    64.                         Thread.sleep(1000);
    65.                     } catch (InterruptedException e) {
    66.                         e.printStackTrace();
    67.                     }
    68.                 });
    69.                 Thread.sleep(500);
    70.             }
    71.         } catch (InterruptedException e) {
    72.             e.printStackTrace();
    73.         }
    74.     }
    75. }

    最开始没处理好worker类的构造函数，在里面直接初始化thread导致了循环引用问题。
    解决方法就是在后面用set方法（这里是包作用域所以不用写setter，但是本质是setter）单独赋值，把环破开即可。