并发编程之线程池

2、线程创建的时机

线程初始化时，线程数为0，在提交任务后，会先检查核心线程数，如果当前线程数小于核心线程数，则创建核心线程执行任务，如果当前线程数大于核心线程数，不会直接创建线程，而是会先提交至队列中，如果队列已满，再校验线程池中的线程数量是否已经达到指定的最大线程数，如果没有达到，则创建非核心线程执行任务，如果已经达到，则执行拒绝策略

3、常见的几种线程池

• FixedThreadPool 

• public static ExecutorService newFixedThreadPool(int nThreads) {
  return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()); }

• 它的核心线程数和最大线程数是一样的，之后的线程数都是固定的，就算任务超过线程数，也不会新建线程；由于线程数是固定的，所以为了防止拒绝任务，使用的队列为无界队列LinkedBlockingQueue

• 适用于长期执行的任务

• CachedThreadPool

• public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue()); }

• 它的核心线程数为0，最大线程数为Integer.MAX_VALUE，由于它的线程数量设置的很大，相当于没有边界，可以不断的新建，所以它使用的队列为SynchronousQueue，这个队列不存储任务，只转交任务给线程

• 适用于并发量大，执行时间短的任务

• ScheduledThreadPool

• public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());}

• 它的最大线程数为Integer.MAX_VALUE，阻塞队列DelayedWorkQueue，该队列可以按照延迟的时间长短对任务进行排序

• 支持定时或周期性执行任务，该线程池有3个方法，分别代表三种不同的周期形式

• service.schedule(new Task(), 10, TimeUnit.SECONDS)

• 延迟指定时间后执行任务，执行完毕后结束

• service.scheduleAtFixedRate(new Task(), 10, 15, TimeUnit.SECONDS)

• 第一次延迟10s后执行任务，之后以每次延迟15s的频率执行任务

• service.scheduleWithFixedDelay(new Task(), 10, 10, TimeUnit.SECONDS)

• 与scheduleAtFixedRate类似，只不过计算时间的起始值不一样，scheduleAtFixedRate是以任务的开始时间作为延迟时间的计时起点，scheduleWithFixedDelay是以任务执行完毕的时间作为延迟时间的计时起点

• SingleThreadExecutor

• public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue())); }

• 核心线程数与最大线程数都为1，可以理解为这是一个只有1个线程的线程池，所以为了防止任务丢失，使用的是无界队列LinkedBlockingQueue

• 适用于串行执行的任务，这也就是为什么只有一个线程，还要用线程池的原因

• ForkJoinPool

• 可以将主任务fork成多个子任务，并行执行，互不影响，最后将子任务执行的结果进行join

• 它跟普通线程池还有个不同的地方就是队列，普通线程池只有一个队列，而它除了用于保存提交任务的队列之外，每个线程都有自己独立的任务队列，用于存储fork之后的任务

• 

• 以下例子，用于实现斐波那契数列0-9的值 (从第3项开始，每一项都等于前两项之和)

• public class TestForkJoinTask extends RecursiveTask { private int i; public TestForkJoinTask(int i) { this.i = i;
  }
  @Override
  protected Integer compute() { if (i <= 1) { return i; } TestForkJoinTask forkJoinTask1 = new TestForkJoinTask(i - 1); forkJoinTask1.fork(); TestForkJoinTask forkJoinTask2 = new TestForkJoinTask(i - 2); forkJoinTask2.fork(); return forkJoinTask1.join() + forkJoinTask2.join(); } }

• public static void testForkJoinPool() { ForkJoinPool forkJoinPool = new ForkJoinPool(); for (int i = 0; i < 100; i++) { ForkJoinTask forkJoinTask = forkJoinPool.submit(new TestForkJoinTask(i));
  System.out.println(forkJoinTask.get()); } }

• CompletableFuture