Java多线程之线程池深入讲解

2021-12-27  本文已影响0人  上善若泪

1 线程池介绍

1.1 线程池概念

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

有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类，熟悉这部分API特征是一项艰难的学习过程

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

1.2 线程池好处

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

2 线程池的使用

2.1 线程池的创建

2.1.1 通过ThreadPoolExecutor创建

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

new ThreadPoolExecutor(corePoolSize, maximumPoolSize,keepAliveTime, milliseconds,
runnableTaskQueue, threadFactory,handler);

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

自定义连接池稍微麻烦些，不过通过创建的ThreadPoolExecutor线程池对象，可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等

2.1.2 通过Executors方式创建

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

ExecutorService pool = Executors.newCachedThreadPool(); 

ExecutorService pool = Executors.newFixedThreadPool(2);

ScheduledExecutorService pool = Executors.newScheduledThreadPool(2); 
将线程放入池中进行执行 
pool.execute(new MyThread()); 
使用延迟执行风格的方法 
pool.schedule(new MyThread(), 10, TimeUnit.MILLISECONDS); 
class MyThread extends Thread { 
        @Override 
        public void run() { 
                System.out.println(Thread.currentThread().getName() + "正在执行。。。"); 
        } 
}

ExecutorService pool = Executors.newSingleThreadExecutor();

2.2 线程池提交的返回值

2.2.1 无返回值

2.2.1.1 execute提交

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

threadsPool.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
});

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的组合：

2.2.3 使用例子

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;

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

image.png

3 线程池的分析

3.1 流程分析

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

另外：当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭

3.2 源码分析

上面的流程分析让我们很直观的了解的线程池的工作原理，让我们再通过源代码来看看是如何实现的。线程池执行任务的方法如下：

public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//如果线程数小于基本线程数，则创建线程并执行当前任务
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
//如线程数大于等于基本线程数或线程创建失败，则将当前任务放到工作队列中。
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
//如果线程池不处于运行中或任务无法放入队列，并且当前线程数量小于最大允许的线程数量，则创建一个线程执行任务。
else if (!addIfUnderMaximumPoolSize(command))
//抛出RejectedExecutionException异常
reject(command); // is shutdown or saturated
}
}

工作线程
线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会无限循环获取工作队列里的任务来执行。我们可以从Worker的run方法里看到这点：

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

4 合理的配置线程池

4.1 线程池分析

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

任务性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务配置尽可能少的线程数量，如配置Ncpu+1个线程的线程池。IO密集型任务则由于需要等待IO操作，线程并不是一直在执行任务，则配置尽可能多的线程，如2*Ncpu。混合型的任务，如果可以拆分，则将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐率要高于串行执行的吞吐率，如果这两个任务执行时间相差太大，则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。

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

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

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

4.2 有界队列

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

5 线程池的监控

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

线程池里有一些属性在监控线程池的时候可以使用：

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

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

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

附：Spring线程池ThreadPoolTaskExecutor的使用

6 线程组

6.1 线程组定义

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

在这里插入图片描述
线程组的作用是：可以批量管理线程或线程组对象，有效地对线程或线程组对象进行组织

相关构造方法：

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

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 和线程池区别

线程组和线程池区别：

上一篇 下一篇

猜你喜欢

热点阅读