多线程——6自定义线程池

自定义线程池

线程池主要关注点

1. 首先需要线程池里面的线程不能停止
2. 还需要一个任务队列（任务队列可以让空闲线程处于wait状态）
3. 线程初始化大小
4. 每个线程run起来之后都必须去看任务里面有没有任务没有任务就wait， 有任务就在同步代码块中取出任务，然后在同步代码块外执行任务

具体实现

public class SimpleThreadPool {

   private final int size;
   private final static int DEFAULT_SIZE = 10;
   //任务队列
   private final static LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();
   //线程池
   private final static List<WorkerTask> THREAD_QUEUE = new ArrayList<>();
   //线程组
   private final static ThreadGroup GROUP = new ThreadGroup("POOL_GROUP");
   //线程名字
   private final static String THREAD_PREFIX = "SIMPLE_THREAD_POOL-";
   private static volatile int seq = 0;

   public SimpleThreadPool() {
       this(DEFAULT_SIZE);
   }

   public SimpleThreadPool(int size) {
       this.size = size;
       init();
   }

   /**
    * 初始化线程池
    */
   private void init() {
       for (int i = 0; i < size; i++) {
           createWorkTask();
       }
   }


   private void createWorkTask() {
       WorkerTask task = new WorkerTask(GROUP, THREAD_PREFIX + (seq++));
       task.start();
       THREAD_QUEUE.add(task);
   }

   /**
    * 提交任务
    */

   public void submit(Runnable task) {
       synchronized (TASK_QUEUE) {
           TASK_QUEUE.addLast(task);
           TASK_QUEUE.notifyAll();
       }
   }



   /**
    * 线程状态
    */
   private enum TaskState {
       FREE,RUNNING,BLOCKED,DEAD
   }


   /**
    * 自定义线程
    */
   private static class WorkerTask extends Thread {

       private volatile TaskState taskState = TaskState.FREE;

       /**
        * 创建线程指定名字
        * @param group
        * @param name
        */
       public WorkerTask(ThreadGroup group, String name) {
           super(group, name);
       }

       @Override
       public void run() {
           OUTER:
           //为了线程不挂掉
           while (this.taskState != TaskState.DEAD) {
               //准备取出任务，认为可能有多个人正在提交任务所以需要锁住
               Runnable runnable;
               synchronized (TASK_QUEUE) {
                   while (TASK_QUEUE.isEmpty()) {
                       try {
                           this.taskState = TaskState.BLOCKED;
                           TASK_QUEUE.wait();
                       } catch (InterruptedException e) {
                           //保证不因为中断异常让线程挂掉
                           break OUTER;
                       }
                   }
                   runnable = TASK_QUEUE.removeFirst();
               }
               //不能把执行任务的代码放到同步代码块中，因为当前线程会独占锁直到任务执行完成
               //这样会导致其他线程无法执行任务，
               //成功线程安全的取出了任务准备执行任务
               this.taskState = TaskState.RUNNING;
               runnable.run();
               this.taskState = TaskState.FREE;
           }
       }


       public void close() {
           this.taskState = TaskState.DEAD;
       }
   }


   public static void main(String[] args) {
       SimpleThreadPool simpleThreadPool = new SimpleThreadPool(40);
       IntStream.rangeClosed(0, 40)
               .forEach(i -> {
                   simpleThreadPool.submit(()->{
                       System.out.println("The runnable " + i + " be serviced by " + Thread.currentThread() + " start.");
                       try {
                           Thread.sleep(10_000);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       System.out.println("The runnable " + i + " be serviced by " + Thread.currentThread() + " finished.");
                   });
               });
   }

}