/**
 * 自定义线程池
 */
class ThreadPool {
   /**
    * 自定义阻塞队列
    */
   private BlockingQueue<Runnable> blockingQueue;
   /**
    * 核心线程数
    */
   private int coreSize;
   private HashSet<Worker> workers = new HashSet<>();
   /**
    * 用于指定线程最大存活时间
    */
   private TimeUnit timeUnit;
   private long timeout;
   /**
    * 工作线程类
    * 内部封装了Thread类，并且添加了一些属性
    */
   private class Worker extends Thread {
      Runnable task;
      public Worker(Runnable task) {
         System.out.println("初始化任务");
         this.task = task;
      }
      @Override
      public void run() {
         // 如果有任务就执行
         // 如果阻塞队列中有任务，就继续执行
         while (task != null || (task = blockingQueue.take()) != null) {
            try {
               System.out.println("执行任务");
               task.run();
            } catch (Exception e) {
               e.printStackTrace();
            } finally {
               // 任务执行完毕，设为空
               System.out.println("任务执行完毕");
               task = null;
            }
         }
         // 移除任务
         synchronized (workers) {
            System.out.println("移除任务");
            workers.remove(this);
         }
      }
   }
   public ThreadPool(int coreSize, TimeUnit timeUnit, long timeout, int capacity) {
      this.coreSize = coreSize;
      this.timeUnit = timeUnit;
      blockingQueue = new BlockingQueue<>(capacity);
      this.timeout = timeout;
   }
   public void execute(Runnable task) {
      synchronized (workers) {
         // 创建任务
         // 池中还有空余线程时，可以运行任务
         // 否则阻塞
         if (workers.size() < coreSize) {
            Worker worker = new Worker(task);
            workers.add(worker);
            worker.start();
         } else {
            System.out.println("线程池中线程已用完，请稍等");
            blockingQueue.put(task);
         }
      }
   }
}

public class Test {
    static AtomicInteger threadId = new AtomicInteger(0);
    public static void main(String[] args) {
        //手动创建线程池
        //创建有界阻塞队列
        ArrayBlockingQueue<Runnable> runnable = new ArrayBlockingQueue<>(10);
        //创建线程工厂
        ThreadFactory threadFactory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r, "working_thread"+threadId.getAndIncrement());
                return thread;
            }
        };
        //手动创建线程池
        //拒绝策略采用默认策略
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 7, 10, TimeUnit.SECONDS, runnable, threadFactory);
        for (int i = 0; i < 20; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread());
                    try {
                        Thread.sleep(100000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

public class TestFixedThreadPool {
    public static void main(String[] args) {
        ThreadFactory factory = new ThreadFactory() {
            AtomicInteger atomicInteger = new AtomicInteger(1);
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "myThread_"+atomicInteger.getAndIncrement());
            }
        };
        //创建核心线程数量为2的线程池
        //通过 ThreadFactory 可以给线程添加名字
        ExecutorService executorService = Executors.newFixedThreadPool(2,factory);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                System.out.println("this is fixedThreadPool");
            }
        };
        executorService.execute(runnable);
    }
}

public static ExecutorService newSingleThreadExecutor() {
  return new FinalizableDelegatedExecutorService(
  new ThreadPoolExecutor(1,1,0L, TimeUnit.MILLSECONDS, 
  new LinkedBlockingQueue<Runnable>()));
}

// 强转为ThreadPoolExecutor
ThreadPoolExecutor threadPool = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
// 改变核心线程数
threadPool.setCorePoolSize(2);

public void shutdown() {
       final ReentrantLock mainlock = this.mainLock;
       mainlock.lock();
       try {
           checkShutdownAccess();
           //修改线程池状态
           advanceRunState(SHUTDOWN);
           //仅会打断空闲线程
           interruptIdleWorkers();
           onShutdown();//扩展点 ScheduleThreadPoolExecutor
       } finally {
           mainlock.unlock();
       }
       //尝试终结(没有运行的线程可以立刻终结，如果还有运行的线程也不会等)
       tryTerminate();
}

public List<Runnable> shutdownNow() {
      List<Runnable> tasks;
      final ReentrantLock mainLock = this.mainLock();
      mainLock.lock();
      try {
          checkShutdownAccess();
          //修改线程池状态
          advanceRunState(STOP);
          //打断所有线程
          interruptWorkers();
          //获取队列中剩余任务
          tasks = drainQueue();
      } finally {
          mainLock.unlock();
      }
      //尝试终结
      tryTerminate();
      return tasks;
}

//不在 RUNNING 状态的线程池，此方法返回 true
boolean isShutdown();
//线程池状态是否是 TERMINATED
boolean isTerminated();
//调用shutdown后，由于调用线程并不会等待所有任务运行结束，因此如果它想在线程池TERMIANTED后做这些事情，可以利用此方法等待
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                System.out.println("task 1");
                sleep(2);
            }
        };
        TimerTask task2 = new TimerTask() {
            @Override
            public void run() {
                System.out.println("task 2");
            }
        };
        //使用timer添加两个任务，希望它们都在1s后执行
        //但由于timer内只有一个线程来顺序执行队列中的任务，因此【任务1】的延时，影响了【任务2】的执行
        timer.schedule(task1, 1000);
        timer.schedule(task2, 1000);
}