Java多线程）快三最快回本方法81512073

1.  public ThreadPoolExecutor(int corePoolSize,
    
2.   int maximumPoolSize,
    
3.   long keepAliveTime,
    
4.   TimeUnit unit,
    
5.   BlockingQueue<Runnable> workQueue) {
    
6.      this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
    
7.           Executors.defaultThreadFactory(), defaultHandler);
    
8.  }
    

10.  public ThreadPoolExecutor(int corePoolSize,
    
11.   int maximumPoolSize,
    
12.   long keepAliveTime,
    
13.   TimeUnit unit,
    
14.   BlockingQueue<Runnable> workQueue,
    
15.   ThreadFactory threadFactory) {
    
16.      this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
    
17.           threadFactory, defaultHandler);
    
18.  }
    

20.  public ThreadPoolExecutor(int corePoolSize,
    
21.   int maximumPoolSize,
    
22.   long keepAliveTime,
    
23.   TimeUnit unit,
    
24.   BlockingQueue<Runnable> workQueue,
    
25.   RejectedExecutionHandler handler) {
    
26.      this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
    
27.           Executors.defaultThreadFactory(), handler);
    
28.  }
    

30.  public ThreadPoolExecutor(int corePoolSize,
    
31.   int maximumPoolSize,
    
32.   long keepAliveTime,
    
33.   TimeUnit unit,
    
34.   BlockingQueue<Runnable> workQueue,
    
35.   ThreadFactory threadFactory,
    
36.   RejectedExecutionHandler handler) {
    
37.      if (corePoolSize < 0 ||
    
38.          maximumPoolSize <= 0 ||
    
39.          maximumPoolSize < corePoolSize ||
    
40.          keepAliveTime < 0)
    
41.          throw new IllegalArgumentException();
    
42.      if (workQueue == null || threadFactory == null || handler == null)
    
43.          throw new NullPointerException();
    
44.      this.corePoolSize = corePoolSize;
    
45.      this.maximumPoolSize = maximumPoolSize;
    
46.      this.workQueue = workQueue;
    
47.      this.keepAliveTime = unit.toNanos(keepAliveTime);
    
48.      this.threadFactory = threadFactory;
    
49.      this.handler = handler;
    
50.  }

能够看到，其须要以下几个参数：

corePoolSize（必需）：核心线程数。默认状况下，核心线程会一直存活，可是当将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。
maximumPoolSize（必需）：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。
keepAliveTime（必需）：线程闲置超时时长。若是超过该时长，非核心线程就会被回收。若是将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。
unit（必需）：指定keepAliveTime参数的时间单位。经常使用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。
workQueue（必需）：任务队列。经过线程池的execute()方法提交的Runnable对象将存储在该参数中。其采用阻塞队列实现。
threadFactory（可选）：线程工厂。用于指定为线程池建立新线程的方式。
handler（可选）：拒绝策略。当达到最大线程数时须要执行的饱和策略。

线程池的使用流程以下：

1.  // 建立线程池
    
2.  ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
    
3.                                               MAXIMUM_POOL_SIZE,
    
4.                                               KEEP_ALIVE,
    
5.                                               TimeUnit.SECONDS,
    
6.                                               sPoolWorkQueue,
    
7.                                               sThreadFactory);
    
8.  // 向线程池提交任务
    
9.  threadPool.execute(new Runnable() {
    
10.      @Override
    
11.      public void run() {
    
12.          ... // 线程执行的任务
    
13.      }
    
14.  });
    
15.  // 关闭线程池
    
16.  threadPool.shutdown(); // 设置线程池的状态为SHUTDOWN，而后中断全部没有正在执行任务的线程
    
17.  threadPool.shutdownNow(); // 设置线程池的状态为 STOP，而后尝试中止全部的正在执行或暂停任务的线程，并返回等待执行任务的列表

3 线程池的工做原理

下面来描述一下线程池工做的原理，同时对上面的参数有一个更深的了解。其工做原理流程图以下：

经过上图，相信你们已经对全部参数有个了解了。下面再对任务队列、线程工厂和拒绝策略作更多的说明。

4 线程池的参数

4.1 任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在Java中须要实现BlockingQueue接口。但Java已经为咱们提供了7种阻塞队列的实现：

ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列（数组结构可配合指针实现一个环形队列）。
LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为Integer.MAX_VALUE。
PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列，对元素没有要求，能够实现Comparable接口也能够提供Comparator来对队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。
DelayQueue：相似于PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现Delayed接口，经过执行时延从队列中提取任务，时间没到任务取不出来。
SynchronousQueue：一个不存储元素的阻塞队列，消费者线程调用take()方法的时候就会发生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就能够拿到这个元素并返回；生产者线程调用put()方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。
LinkedBlockingDeque：使用双向队列实现的有界双端阻塞队列。双端意味着能够像普通队列同样FIFO（先进先出），也能够像栈同样FILO（先进后出）。
LinkedTransferQueue：它是ConcurrentLinkedQueue、LinkedBlockingQueue和SynchronousQueue的结合体，可是把它用在ThreadPoolExecutor中，和LinkedBlockingQueue行为一致，可是是无界的阻塞队列。

注意有界队列和无界队列的区别：若是使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而若是使用无界队列，由于任务队列永远均可以添加任务，因此设置maximumPoolSize没有任何意义。

4.2 线程工厂（threadFactory）

线程工厂指定建立线程的方式，须要实现ThreadFactory接口，并实现newThread(Runnable r)方法。该参数能够不用指定，Executors框架已经为咱们实现了一个默认的线程工厂：

1.  /**
    
2.   * The default thread factory.
    
3.   */
    
4.  private static class DefaultThreadFactory implements ThreadFactory {
    
5.      private static final AtomicInteger poolNumber = new AtomicInteger(1);
    
6.      private final ThreadGroup group;
    
7.      private final AtomicInteger threadNumber = new AtomicInteger(1);
    
8.      private final String namePrefix;
    

10.      DefaultThreadFactory() {
    
11.          SecurityManager s = System.getSecurityManager();
    
12.          group = (s != null) ? s.getThreadGroup() :
    
13.                                Thread.currentThread().getThreadGroup();
    
14.          namePrefix = "pool-" +
    
15.                        poolNumber.getAndIncrement() +
    
16.                       "-thread-";
    
17.      }
    

19.      public Thread newThread(Runnable r) {
    
20.          Thread t = new Thread(group, r,
    
21.                                namePrefix + threadNumber.getAndIncrement(),
    
22.                                0);
    
23.          if (t.isDaemon())
    
24.              t.setDaemon(false);
    
25.          if (t.getPriority() != Thread.NORM_PRIORITY)
    
26.              t.setPriority(Thread.NORM_PRIORITY);
    
27.          return t;
    
28.      }
    
29.  }

4.3 拒绝策略（handler）

当线程池的线程数达到最大线程数时，须要执行拒绝策略。拒绝策略须要实现RejectedExecutionHandler接口，并实现rejectedExecution(Runnable r, ThreadPoolExecutor executor)方法。不过Executors框架已经为咱们实现了4种拒绝策略：

AbortPolicy（默认）：丢弃任务并抛出RejectedExecutionException异常。
CallerRunsPolicy：由调用线程处理该任务。
DiscardPolicy：丢弃任务，可是不抛出异常。能够配合这种模式进行自定义的处理方式。
DiscardOldestPolicy：丢弃队列最先的未处理任务，而后从新尝试执行任务。

5 功能线程池

嫌上面使用线程池的方法太麻烦？其实Executors已经为咱们封装好了4种常见的功能线程池，以下：

定长线程池（FixedThreadPool）
定时线程池（ScheduledThreadPool ）
可缓存线程池（CachedThreadPool）
单线程化线程池（SingleThreadExecutor）

5.1 定长线程池（FixedThreadPool）

建立方法的源码：

1.  public static ExecutorService newFixedThreadPool(int nThreads) {
    
2.      return new ThreadPoolExecutor(nThreads, nThreads,
    
3.                                    0L, TimeUnit.MILLISECONDS,
    
4.                                    new LinkedBlockingQueue<Runnable>());
    
5.  }
    
6.  public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    
7.      return new ThreadPoolExecutor(nThreads, nThreads,
    
8.                                    0L, TimeUnit.MILLISECONDS,
    
9.                                    new LinkedBlockingQueue<Runnable>(),
    
10.                                    threadFactory);
    
11.  }

特色：只有核心线程，线程数量固定，执行完当即回收，任务队列为链表结构的有界队列。
应用场景：控制线程最大并发数。

使用示例：

1.  // 1. 建立定长线程池对象 & 设置线程池线程数量固定为3
    
2.  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    
3.  // 2. 建立好Runnable类线程对象 & 需执行的任务
    
4.  Runnable task =new Runnable(){
    
5.    public void run() {
    
6.       System.out.println("执行任务啦");
    
7.    }
    
8.  };
    
9.  // 3. 向线程池提交任务
    
10.  fixedThreadPool.execute(task);

5.2 定时线程池（ScheduledThreadPool ）

建立方法的源码：

1.  private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;
    

3.  public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    
4.      return new ScheduledThreadPoolExecutor(corePoolSize);
    
5.  }
    
6.  public ScheduledThreadPoolExecutor(int corePoolSize) {
    
7.      super(corePoolSize, Integer.MAX_VALUE,
    
8.            DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
    
9.            new DelayedWorkQueue());
    
10.  }
    

12.  public static ScheduledExecutorService newScheduledThreadPool(
    
13.          int corePoolSize, ThreadFactory threadFactory) {
    
14.      return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    
15.  }
    
16.  public ScheduledThreadPoolExecutor(int corePoolSize,
    
17.   ThreadFactory threadFactory) {
    
18.      super(corePoolSize, Integer.MAX_VALUE,
    
19.            DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
    
20.            new DelayedWorkQueue(), threadFactory);
    
21.  }

特色：核心线程数量固定，非核心线程数量无限，执行完闲置10ms后回收，任务队列为延时阻塞队列。
应用场景：执行定时或周期性的任务。

使用示例：

1.  // 1. 建立 定时线程池对象 & 设置线程池线程数量固定为5
    
2.  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
    
3.  // 2. 建立好Runnable类线程对象 & 需执行的任务
    
4.  Runnable task =new Runnable(){
    
5.    public void run() {
    
6.       System.out.println("执行任务啦");
    
7.    }
    
8.  };
    
9.  // 3. 向线程池提交任务
    
10.  scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务
    
11.  scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务

5.3 可缓存线程池（CachedThreadPool）

建立方法的源码：

1.  public static ExecutorService newCachedThreadPool() {
    
2.      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
    
3.                                    60L, TimeUnit.SECONDS,
    
4.                                    new SynchronousQueue<Runnable>());
    
5.  }
    
6.  public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    
7.      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
    
8.                                    60L, TimeUnit.SECONDS,
    
9.                                    new SynchronousQueue<Runnable>(),
    
10.                                    threadFactory);
    
11.  }

特色：无核心线程，非核心线程数量无限，执行完闲置60s后回收，任务队列为不存储元素的阻塞队列。
应用场景：执行大量、耗时少的任务。

使用示例：

1.  // 1. 建立可缓存线程池对象
    
2.  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    
3.  // 2. 建立好Runnable类线程对象 & 需执行的任务
    
4.  Runnable task =new Runnable(){
    
5.    public void run() {
    
6.       System.out.println("执行任务啦");
    
7.    }
    
8.  };
    
9.  // 3. 向线程池提交任务
    
10.  cachedThreadPool.execute(task);

5.4 单线程化线程池（SingleThreadExecutor）

建立方法的源码：

1.  public static ExecutorService newSingleThreadExecutor() {
    
2.      return new FinalizableDelegatedExecutorService
    
3.          (new ThreadPoolExecutor(1, 1,
    
4.                                  0L, TimeUnit.MILLISECONDS,
    
5.                                  new LinkedBlockingQueue<Runnable>()));
    
6.  }
    
7.  public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    
8.      return new FinalizableDelegatedExecutorService
    
9.          (new ThreadPoolExecutor(1, 1,
    
10.                                  0L, TimeUnit.MILLISECONDS,
    
11.                                  new LinkedBlockingQueue<Runnable>(),
    
12.                                  threadFactory));
    
13.  }

特色：只有1个核心线程，无非核心线程，执行完当即回收，任务队列为链表结构的有界队列。
应用场景：不适合并发但可能引发IO阻塞性及影响UI线程响应的操做，如数据库操做、文件操做等。

使用示例：

1.  // 1. 建立单线程化线程池
    
2.  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
    
3.  // 2. 建立好Runnable类线程对象 & 需执行的任务
    
4.  Runnable task =new Runnable(){
    
5.    public void run() {
    
6.       System.out.println("执行任务啦");
    
7.    }
    
8.  };
    
9.  // 3. 向线程池提交任务
    
10.  singleThreadExecutor.execute(task);

5.5 对比

6 总结

Executors的4个功能线程池虽然方便，但如今已经不建议使用了，而是建议直接经过使用ThreadPoolExecutor的方式，这样的处理方式让写的同窗更加明确线程池的运行规则，规避资源耗尽的风险。

其实Executors的4个功能线程有以下弊端：

FixedThreadPool和SingleThreadExecutor：主要问题是堆积的请求处理队列均采用LinkedBlockingQueue，可能会耗费很是大的内存，甚至OOM。
CachedThreadPool和ScheduledThreadPool：主要问题是线程数最大数是Integer.MAX_VALUE，可能会建立数量很是多的线程，甚至OOM。