[Java] 一篇文章带你深入了解Java线程池

public interface XXPool{
  XX acquire(); 
  void release();
}

//简化的线程池，仅用来说明工作原理
class MyThreadPool{
  //利用阻塞队列实现生产者-消费者模式
  BlockingQueue<Runnable> workQueue;
  //保存内部工作线程
  List<WorkerThread> threads 
  = new ArrayList<>();
  // 构造方法
  MyThreadPool(int poolSize, 
  BlockingQueue<Runnable> workQueue){
  this.workQueue = workQueue;
  // 创建工作线程
  for(int idx=0; idx<poolSize; idx++){
    WorkerThread work = new WorkerThread();
    work.start();
    threads.add(work);
  }
  }
  // 提交任务
  void execute(Runnable command){
  workQueue.put(command);
  }
  // 工作线程负责消费任务，并执行任务
  class WorkerThread extends Thread{
  public void run() {
    //循环取任务并执行
    while(true){ ①
    Runnable task = workQueue.take();
    task.run();
    } 
  }
  }  
}
 
/** 下面是使用示例 **/
// 创建有界阻塞队列
BlockingQueue<Runnable> workQueue = 
  new LinkedBlockingQueue<>(2);
// 创建线程池  
MyThreadPool pool = new MyThreadPool(
  10, workQueue);
// 提交任务  
pool.execute(()->{
  System.out.println("hello");
});

ExecutorService executorService = Executors.newFixedThreadPool(threadPoolNum, r -> new Thread(r, threadName));

ThreadPoolExecutor(
  int corePoolSize,
  int maximumPoolSize,
  long keepAliveTime,
  TimeUnit unit,
  BlockingQueue<Runnable> workQueue,
  ThreadFactory threadFactory,
  RejectedExecutionHandler handler)

• CallerRunsPolicy：提交任务的线程自己去执行该任务。
  
• AbortPolicy：默认的拒绝策略，会 throws RejectedExecutionException。
  
• DiscardPolicy：直接丢弃任务，没有任何异常抛出。
  
• DiscardOldestPolicy：丢弃最老的任务，其实就是把最早进入工作队列的任务丢弃，然后把新任务加入到工作队列。
  

public static void main(String[] args) {
    ForkJoinPool forkJoinPool = new ForkJoinPool(4);
 
    Fibonacci fibonacci = new Fibonacci(5);
    Integer res = forkJoinPool.invoke(fibonacci);
 
    System.out.println(res);
  }
 
  static class Fibonacci extends RecursiveTask<Integer>{
    final int n;
    Fibonacci(int n){
      this.n = n;
    }
    @Override
    protected Integer compute() {
      if(n<=1){
        return n;
      }
      Fibonacci f1 = new Fibonacci(n-1);
      f1.fork();
      Fibonacci f2 = new Fibonacci(n-2);
      return f2.compute() + f1.join();
    }
  }

// 取消任务
boolean cancel(
  boolean mayInterruptIfRunning);
// 判断任务是否已取消  
boolean isCancelled();
// 判断任务是否已结束
boolean isDone();
// 获得任务执行结果
get();
// 获得任务执行结果，支持超时
get(long timeout, TimeUnit unit);

ExecutorService executorService = Executors.newFixedThreadPool(10);
    Future<Integer> future = executorService.submit(() -> {
      return 1 + 1;
    });
    Integer res = future.get();
    System.out.println(res);
    Integer res2 = future.get(1000, TimeUnit.SECONDS);
    System.out.println(res2);

// 创建FutureTask
FutureTask<Integer> futureTask
  = new FutureTask<>(()-> 1+2);
// 创建线程池
ExecutorService es = 
  Executors.newCachedThreadPool();
// 提交FutureTask 
es.submit(futureTask);
// 获取计算结果
Integer result = futureTask.get();