标签：Thread 队列 创建 任务 线程 执行 ThreadPoolExecutor

线程池ThreadPoolExecutor

1、线程池介绍

1.1 线程池概念

Sun在Java5中，对Java线程的类库做了大量的扩展，其中线程池就是Java5的新特征之一，除了线程池之外，还有很多多线程相关的内容，为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序，线程部分的新增内容显得尤为重要。

有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类。

线程池的基本思想是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

1.2 线程池好处

合理利用线程池能够带来三个好处
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行
第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。

2、线程池的使用

2.1 线程池的创建

2.1.1 通过ThreadPoolExecutor创建

可以通过ThreadPoolExecutor来创建一个线程池

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

创建一个线程池需要输入几个参数：

• corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。
• runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列：
  • ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。
  • LinkedBlockingQueue：一个基于链表结构的 有界阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()和newSingleThreadExecutor使用了这个队列。
  • SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
  • PriorityBlockingQueue：一个具有优先级得无限阻塞队列。
  • DelayedWorkQueue：一个使用优先级队列实现的无界阻塞队列，静态工厂方法Executors.newScheduledThreadPool使用
• maximumPoolSize（线程池最大大小）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。
• ThreadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字，Debug和定位问题时非常有帮助。
• RejectedExecutionHandler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略：
  • AbortPolicy：直接抛出异常。
  • CallerRunsPolicy：只用调用者所在线程来运行任务。
  • DiscardOldestPolicy：丢弃队列里最早进入一个任务，并执行当前任务。
  • DiscardPolicy：不处理，丢弃掉。
  • 自定义策略：当然也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

• keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。

• TimeUnit（线程活动保持时间的单位）：可选的单位有天（DAYS），小时（HOURS），分钟（MINUTES），毫秒(MILLISECONDS)，微秒(MICROSECONDS, 千分之一毫秒)和毫微秒(NANOSECONDS, 千分之一微秒)

2.1.2 通过Executors方式创建

Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：

• newCachedThreadPool: 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
• newFixedThreadPool: 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
• newScheduledThreadPool: 创建一个定长线程池，支持定时及周期性任务执行
• newSingleThreadExecutor:  创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

2.2 线程池提交的返回值

2.2.1 无返回值

2.2.1.1 execute提交

可使用execute提交任务，但execute方法没有返回值，所以无法判断任务是否被线程池执行成功。通过以下代码可知execute方法输入的任务是一个Runnable类的实例

threadPool.execute(new Runnable() {
            @Override
            public void run() {
                // TODO execute task
            }
        });

2.2.1.2 实现Runnable接口

无返回值的任务必须实现Runnable接口重写run方法，方法的异常只能在内部消化，不能继续上抛。

2.2.2 有返回值

2.2.2.1 submit提交

也可以使用submit方法来提交任务，它会返回一个future，可通过这个future来判断任务是否执行成功，通过future的get方法来获取返回值， get方法会阻塞住直到任务完成 ，而使用get(long timeout, TimeUnit unit)方法则会阻塞一段时间后立即返回，这时有可能任务没有执行完。

try {
            Object s = future.get();
        } catch (InterruptedException e) {
// 处理中断异常
        } catch (ExecutionException e) {
// 处理无法执行任务异常
        } finally {
// 关闭线程池
            executor.shutdown();
        }

2.2.2.2 实现Callable接口

有返回值的任务必须实现Callable接口重写call方法且方法允许抛出异常
要想有返回值，那么submit的组合：

submit(Callable<T> task) 能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。一般使用FutureTask + Callable配合使用
submit(Runnable task, T result) 能通过传入的载体result间接获得线程的返回值。
submit(Runnable task) 则是没有返回值的，就算获取它的返回值也是null

public void testFuture() throws InterruptedException {
       ExecutorService executor = Executors.newCachedThreadPool();
       Task task = new Task();
       NewTask newTask = new NewTask();
       Future<Integer> result = executor.submit(task);
       Future<String> ends = executor.submit(newTask);
       executor.shutdown();
       System.out.println("主线程开始运行");
       System.out.println("主线程做一些复杂任务");
       Thread.sleep(10000);
       System.out.println("主线程需要子线程的计算结果");
       try {
               System.out.println("主线程得到子线程的结果："+result.get());
               System.out.println("主线程需要第二个子线程的数据:"+ends.get());
        } catch (InterruptedException e) {
               e.printStackTrace();
        } catch (ExecutionException e) {
               e.printStackTrace();
        }
        System.out.println("所有均完毕");
}
class Task implements Callable<Integer>{
        public Integer call() throws Exception {
                System.out.println("子线程计算开始");
                Thread.sleep(3000);
                int sum = 0;
                for (int i=0;i<100000;i++){
                        sum += i ;
                }
                System.out.println("子线程已经计算完毕");
                return sum;
        }
}
class  NewTask implements  Callable<String>{
        public String call() throws Exception {
                System.out.println("第二个子线程已经运行完毕");
                return "success";
        }
}

2.3 线程池的关闭

可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池，但是它们的实现原理不同：
shutdown的原理是只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程 。
shutdownNow的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。shutdownNow会首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表。
只要调用了这两个关闭方法的其中一个，isShutdown方法就会返回true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。

至于我们应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow。

2.4 线程池状态分析

线程池和线程的状态是不一样的，线程池有这几个状态：RUNNING，SHUTDOWN，STOP，TIDYING，TERMINATED

//线程池状态
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

线程池各个状态切换状态图如下：

     *   RUNNING:  Accept new tasks and process queued tasks
     *   SHUTDOWN: Don't accept new tasks, but process queued tasks
     *   STOP:     Don't accept new tasks, don't process queued tasks,
     *             and interrupt in-progress tasks
     *   TIDYING:  All tasks have terminated, workerCount is zero,
     *             the thread transitioning to state TIDYING
     *             will run the terminated() hook method
     *   TERMINATED: terminated() has completed

* RUNNING -> SHUTDOWN
*    On invocation of shutdown(), perhaps implicitly in finalize()
* (RUNNING or SHUTDOWN) -> STOP
*    On invocation of shutdownNow()
* SHUTDOWN -> TIDYING
*    When both queue and pool are empty
* STOP -> TIDYING
*    When pool is empty
* TIDYING -> TERMINATED
*    When the terminated() hook method has completed
*
* Threads waiting in awaitTermination() will return when the
* state reaches TERMINATED.

1）RUNNING
该状态的线程池会接收新任务，并处理阻塞队列中的任务；
调用线程池的shutdown()方法，可以切换到SHUTDOWN状态；
调用线程池的shutdownNow()方法，可以切换到STOP状态；
2）SHUTDOWN
该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
队列为空，并且线程池中执行的任务也为空,进入TIDYING状态；
3）STOP
该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
线程池中执行的任务为空，进入TIDYING状态；
4）TIDYING
该状态表明所有的任务已经运行终止，记录的任务数量为0
terminated()执行完毕，进入TERMINATED状态
5）TERMINATED
该状态表示线程池彻底终止

3、线程池的分析

3.1 流程分析

Java线程池主要工作流程：
当提交一个新任务到线程池时，线程池的处理流程如下：

首先线程池判断核心线程数corePoolSize是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程。
其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。
最后线程池判断线程池的最大线程数maximumPoolSize是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给拒绝策略来处理这个任务。
另外：当线程池中线程数大于corePoolSize数，空闲线程空闲时间达到keepAliveTime时，关闭空闲线程。
当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭。
 

线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会无限循环获取工作队列里的任务来执行。

可以从Worker的run方法里看到这点：

public void runWorker() {
     try {
          Runnable task = firstTask;
          firstTask = null;
          while (task != null || (task = getTask()) != null) {
                   runTask(task);
                    task = null;
           }
      } finally {
             workerDone(this);
    }
}

4、合理的配置线程池

4.1 线程池分析

要想合理的配置线程池，就必须首先分析任务特性，可以从以下几个角度来进行分析：

• 任务的性质：CPU密集型任务，IO密集型任务和混合型任务。
• 任务的优先级：高，中和低。
• 任务的执行时间：长，中和短。
• 任务的依赖性：是否依赖其他系统资源，如数据库连接。

任务性质不同的任务可以用不同规模的线程池分开处理。

CPU密集型任务配置尽可能少的线程数量，如配置Ncpu+1个线程的线程池。

IO密集型任务则由于需要等待IO操作，线程并不是一直在执行任务，则配置尽可能多的线程，如2*Ncpu。

混合型的任务，如果可以拆分，则将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐率要高于串行执行的吞吐率，如果这两个任务执行时间相差太大，则没必要进行分解。可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。

优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先得到执行，需要注意的是如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。

执行时间不同的任务可以交给不同规模的线程池来处理，或者也可以使用优先级队列，让执行时间短的任务先执行。

依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，如果等待的时间越长CPU空闲时间就越长，那么线程数应该设置越大，这样才能更好的利用CPU。

4.2 有界队列

建议使用有界队列，有界队列能增加系统的稳定性和预警能力，可以根据需要设大一点，比如几千。

有一次使用的后台任务线程池的队列和线程池全满了，不断的抛出抛弃任务的异常，通过排查发现是数据库出现了问题，导致执行SQL变得非常缓慢，因为后台任务线程池里的任务全是需要向数据库查询和插入数据的，所以导致线程池里的工作线程全部阻塞住，任务积压在线程池里。如果当时我们设置成无界队列，线程池的队列就会越来越多，有可能会撑满内存，导致整个系统不可用，而不只是后台任务出现问题。

5、 线程池的监控

5.1 通过线程池提供参数监控

主要说的是自定义线程池，而不是通过ThreadPoolExecutor线程池对象创建
线程池里有一些属性在监控线程池的时候可以使用：

• taskCount：线程池需要执行的任务数量。
• completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCount
• largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。
• getPoolSize：线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不减。
• getActiveCount：获取活动的线程数。

5.2 通过扩展线程池进行监控

通过继承线程池并重写线程池的beforeExecute，afterExecute和terminated方法，可以在任务执行前，执行后和线程池关闭前干一些事情。如监控任务的平均执行时间，最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如：

protected void beforeExecute(Thread t, Runnable r) { }

6、线程组

6.1 线程组定义

可以把线程归属到某一个线程组中，线程组中可以有线程对象，也可以有线程组，组中还可以有线程，这样的组织结构有点类似于树的形式，如图所示.

 

 

线程组的作用是：可以批量管理线程或线程组对象，有效地对线程或线程组对象进行组织

相关构造方法：

ThreadGroup(String name):构造一个新线程组
ThreadGroup(ThreadGroup parent,String name):构造一个新线程组
注意一下第二个，假如要使用多级关联一般就是用第二个构造函数。第一个参数表示新线程组的父线程组，第二个参数表示新线程组的名称，有了父线程组和新线程组的名称，自然可以构造出一个新的线程组来了。
注意：线程必须启动后才能归到指定线程组中。

6.2 使用操作

ThreadGroup其实比ExecutorService更好
用java做抓取的时候免不了要用到多线程，因为要同时抓取多个网站或一条线程抓取一个网站的话实在太慢，而且有时一条线程抓取同一个网站的话也比较浪费CPU资源。要用到多线程的等方面，也就免不了对线程的控制或用到线程池。

 import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
 public class JavaThreadPool {
    public static void main(String[] args) {
        // 创建一个可重用固定线程数的线程池
         ExecutorService pool = Executors.newFixedThreadPool(2);
        // 创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        // 将线程放入池中进行执行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        // 关闭线程池
        pool.shutdown();
    }
}
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");
    }
}

后来发现ExecutorService的功能没有想像中的那么好，而且只是提供一个线程的容器而已，所以后来改用了java.lang.ThreadGroup，ThreadGroup有很多优势，最重要的一点就是它可以对线程进行遍历，知道那些线程已经运行完毕，还有那些线程在运行。关于ThreadGroup的使用代码如下：

class MyThread extends Thread {   
   boolean stopped;   
   MyThread(ThreadGroup tg, String name) {   
       super(tg, name);  
       stopped = false;   
   }   
   public void run() {  
       System.out.println(Thread.currentThread().getName() + " starting.");  
       try {  
            for (int i = 1; i < 1000; i++) {  
                System.out.print(".");  
                Thread.sleep(250);  
                synchronized (this) {  
                    if (stopped)break;  
                }  
            }  
        } catch (Exception exc) {  
            System.out.println(Thread.currentThread().getName() + " interrupted.");  
        }  
        System.out.println(Thread.currentThread().getName() + " exiting.");  
    }  
    synchronized void myStop() {  
        stopped = true;  
    }  
}  
public class Main {  
    public static void main(String args[]) throws Exception {  
        ThreadGroup tg = new ThreadGroup("My Group");  
        MyThread thrd = new MyThread(tg, "MyThread #1");  
        MyThread thrd2 = new MyThread(tg, "MyThread #2");  
        MyThread thrd3 = new MyThread(tg, "MyThread #3");  
        thrd.start();  
        thrd2.start();  
        thrd3.start();  
        Thread.sleep(1000);  
        System.out.println(tg.activeCount() + " threads in thread group.");  
        Thread thrds[] = new Thread[tg.activeCount()];  
        tg.enumerate(thrds);  
        for (Thread t : thrds)  
            System.out.println(t.getName());  
        thrd.myStop();  
        Thread.sleep(1000);  
        System.out.println(tg.activeCount() + " threads in tg.");  
        tg.interrupt();  
    }  
} 

由以上的代码可以看出：ThreadGroup比ExecutorService多以下几个优势

1. ThreadGroup可以遍历线程，知道那些线程已经运行完毕，那些还在运行
2. 可以通过ThreadGroup.activeCount知道有多少线程从而可以控制插入的线程数

6.3 和线程池区别

线程组：
线程组存在的意义，首要原因是安全
java默认创建的线程都是属于系统线程组，而同一个线程组的线程是可以相互修改对方的数据。
但如果在不同的线程组中，那么就不能跨线程组修改数据，可以从一定程度上保证数据安全。
线程池：
线程池存在的意义，首要作用是效率
线程的创建和结束都需要耗费一定的系统时间（特别是创建），不停创建和删除线程会浪费大量的时间。所以，在创建出一条线程并使其在执行完任务后不结束，而是使其进入休眠状态，在需要用时再唤醒，那么 就可以节省一定的时间。
如果这样的线程比较多，那么就可以使用线程池来进行管理。保证效率。
线程组和线程池共有的特点：
都是管理一定数量的线程
都可以对线程进行控制—包括休眠，唤醒，结束，创建，中断（暂停）–但并不一定包含全部这些操作。

参考文章

 

标签：Thread,队列,创建,任务,线程,执行,ThreadPoolExecutor
From： https://www.cnblogs.com/longan-wang/p/16563227.html