java 线程池（线程的复用）

柔情只为你懂 2021-12-16 03:49 348阅读 0赞

# 一. 线程池简介　 #

**1. 线程池的概念：**

线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

**2. 线程池的工作机制**

2.1 在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。

2.1 一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

![885859-20190520161447031-441783867.png][]

**3. 使用线程池的好处**

Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处：

**第一：降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

**第二：提高响应速度**。当任务到达时，任务可以不需要等到线程创建就能立即执行。

**第三：提高线程的可管理性**。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

--------------------

**二：JDK对线程池的支持**

JDK提供的Executor框架

JDK提供了Executor框架，可以让我们有效的管理和控制我们的线程，其实质也就是一个线程池。Executor下的接口和类继承关系如下：

![885859-20190520161650426-1078862332.png][]

**Executors：**提供了一系列静态工厂方法用于创建各种线程池

![885859-20190520162408345-2067486896.png][]

其中常用几类如下：

public static ExecutorService newFixedThreadPool()
    public static ExecutorService newSingleThreadExecutor()
    public static ExecutorService newCachedThreadPool()
    public static ScheduledExecutorService newSingleThreadScheduledExecutor()
    public static ScheduledExecutorService newScheduledThreadPool()

1、newFixedThreadPool：该方法返回一个固定线程数量的线程池；

2、newSingleThreadExecutor：该方法返回一个只有一个现成的线程池；

3、newCachedThreadPool：返回一个可以根据实际情况调整线程数量的线程池；

4、newSingleThreadScheduledExecutor：该方法和newSingleThreadExecutor的区别是给定了时间执行某任务的功能，可以进行定时执行等；

5、newScheduledThreadPool：在4的基础上可以指定线程数量。

**　创建线程池实质调用的还是ThreadPoolExecutor**

在Executors类中，我们拿出来一个方法简单分析一下：

![885859-20190520162644781-40729645.png][]

可以看出，类似的其他方法一样，**在Executors内部创建线程池的时候，实际创建的都是一个ThreadPoolExecutor对象**，只是对ThreadPoolExecutor构造方法，进行了默认值的设定。ThreadPoolExecutor的构造方法如下：

![885859-20190520162804534-704381292.png][]

参数含义如下：

1、corePoolSize 核心线程池大小；
    2、maximumPoolSize 线程池最大容量大小；
    3、keepAliveTime 线程池空闲时，线程存活的时间；
    4、TimeUnit 时间单位；
    5、ThreadFactory 线程工厂；
    6、BlockingQueue任务队列；
    7、RejectedExecutionHandler 线程拒绝策略；

## Executor框架实例 ##

1、实例一：

public class ThreadPoolDemo {
     
        public static void main(String[] args) {
     
            ExecutorService executorService = Executors.newFixedThreadPool(4);
     
            for (int i = 0; i < 10; i++) {
                int index = i;
                executorService.submit(() -> System.out.println("i:" + index +
                        " executorService"));
            }
            executorService.shutdown();
        }
    }

submit(Runnable task)方法提交一个线程。

但是使用最新的“阿里巴巴编码规范插件”检测一下会发现：

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，
    这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 
    说明：Executors各个方法的弊端：
     
    1）newFixedThreadPool和newSingleThreadExecutor:
      主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
    2）newCachedThreadPool和newScheduledThreadPool:
      主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。

2、实例二：

遵循阿里巴巴编码规范的提示，示例如下：

public class ThreadPoolDemo {
     
        public static void main(String[] args) {
     
            ExecutorService executorService = new ThreadPoolExecutor(2, 2, 0L, 
                    TimeUnit.MILLISECONDS, 
                    new LinkedBlockingQueue<>(10), 
                    Executors.defaultThreadFactory(), 
                    new ThreadPoolExecutor.AbortPolicy());
     
            for (int i = 0; i < 10; i++) {
                int index = i;
                executorService.submit(() -> System.out.println("i:" + index + 
                        " executorService"));
            }
            executorService.shutdown();
        }
    }

或者这样：

public class ThreadPoolDemo {
     
        public static void main(String[] args) {
     
            ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 2, 0L,
                    TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>(10),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy());
     
            for (int i = 0; i < 10; i++) {
                int index = i;
                pool.submit(() -> System.out.println("i:" + index +
                        " executorService"));
            }
            pool.shutdown();
        }
    }

3、实例三：

自定义ThreadFactory、自定义线程拒绝策略

public static void main(String[] args) {
     
            ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>(10),
                    new ThreadFactory() { //自定义ThreadFactory
                        @Override
                        public Thread newThread(Runnable r) {
                            Thread thread = new Thread(r);
                            thread.setName(r.getClass().getName());
                            return thread;
                        }
                    },
                    new ThreadPoolExecutor.AbortPolicy()); //自定义线程拒绝策略
     
            for (int i = 0; i < 10; i++) {
                int index = i;
                executorService.submit(() -> System.out.println("i:" + index));
            }
     
            executorService.shutdown();
        }
    }

## 使用submit的坑 ##

首先看一下实例：

public class ThreadPoolDemo3 {
     
        public static void main(String[] args) {
     
            ExecutorService executorService = Executors.newFixedThreadPool(4);
     
            for (int i = 0; i < 5; i++) {
                int index = i;
                executorService.submit(() -> divTask(100, index));
            }
            executorService.shutdown();
        }
    private static void divTask(int a, int b) {
            double result = a / b;
            System.out.println(result);
        }
    }

运行结果：

![885859-20190520163253939-345303126.png][]

上述代码，可以看出运行结果为4个，因该是有5个的，但是当`i=0`的时候，`100/0`是会报错的，但是日志信息中没有任何信息，是为什么那？如果使用了`submit(Runnable task)` 就会出现这种情况，任何的错误信息都出现不了！

这是因为使用`submit(Runnable task)` 的时候，错误的堆栈信息跑出来的时候会被内部捕获到，所以打印不出来具体的信息让我们查看，解决的方法有如下两种：

1、使用execute（）代替submit（）；

public class ThreadPoolDemo3 {
     
        public static void main(String[] args) {
     
            ExecutorService executorService = Executors.newFixedThreadPool(4);
     
            for (int i = 0; i < 5; i++) {
                int index = i;
                executorService.execute(() -> divTask(100, index));
            }
            executorService.shutdown();
        }
     
        private static void divTask(int a, int b) {
            double result = a / b;
            System.out.println(result);
        }
    }

运行结果：

![885859-20190520163322803-390276509.png][]

2、使用Future

public class ThreadPoolDemo3 {
     
        public static void main(String[] args) {
     
            ExecutorService executorService = Executors.newFixedThreadPool(4);
     
            for (int i = 0; i < 5; i++) {
                int index = i;
                Future future = executorService.submit(() -> divTask(200, index));
                try {
                    future.get();
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
            executorService.shutdown();
        }
     
        private static void divTask(int a, int b) {
            double result = a / b;
            System.out.println(result);
        }
    }

运行结果：

![885859-20190520163350180-34212698.png][]

3、execute和submit的区别

（1）`execute()`方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。通过以下代码可知`execute()`方法输入的任务是一个Runnable类的实例。

（2）`submit()`方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的`get()`方法来获取返回值，`get()`方法会阻塞当前线程直到任务完成，而使用`get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

--------------------

**思考：线程池中的工作线程是如何实现线程复用的？**

一个线程一般在执行完任务后就结束了，怎么再让他执行下一个任务呢？

线程重用的核心是，我们知道， Thread.start()只能调用一次，一旦这个调用结束，则该线程就到了stop状态，不能再次调用start。  
则要达到复用的目的，则必须从Runnable接口的run()方法上入手，可以这样设计这个Runnable.run()方法（就叫外面的run()方法）：  
它 本质上是个无限循环，跑的过程中不断检查我们是否有新加入的子Runnable对象（就叫内部的runnable:run()吧，它就是用来实现我们自己的任务），有就调一下我们的run()，其实就一个大run()把其它小run()\#1,run()\#2,...给串联起来了，基本原理就这么简单  
不停地处理我们提交的Runnable任务。

public void run() {
        while(true) {
            if(tasks available) {
               Runnable task = taskqueue.dequeue();
               task.run();
            } else {
               // wait or whatever
            }
        }
    }

下面举个代码实例来模拟实现线程池复用线程

生产了两个 线程作为工人

生产了10个同样的任务，让他们执行

利用复用让 2个线程完成10个任务

import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.concurrent.TimeUnit;
    
    public class Mythreadpool {
        LinkedList<Task> taskList = new LinkedList<Task>();
        
        class Task { //任务类
            int id;
            Task(int id){
                this.id=id;
                System.out.println("第"+id+"个任务产生");
            }
            public void run() {
        //具体的工作
                System.out.println("第"+id+"个任务正在执行");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第"+id+"个任务执行完毕");
            }
        }
        
        class Worker extends Thread { //工人实体
            String name;
            Worker(String name) {
                this.name = name;
            }
            
            public void run() {
                while(true) {
                    if(taskList.size() == 0) {
                        try {
                            synchronized (taskList) {
                                System.out.println("Worker " + name+" 没有任务");
                                taskList.wait(); //没得到任务，进入tasklist的等待队列
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    synchronized (taskList) {
                        System.out.println("Worker " + name+" 得到任务");
                        taskList.removeFirst().run();
                    }
                }
            }
        }
        
        void pool() {  //工人。只生产了两个工人
             ArrayList<Worker> wokerlist=new ArrayList<Worker>();
             for(int i=0;i<2;i++) {
                 Worker k = new Worker("第"+(i+1)+"个工人");
                 k.start();
                 wokerlist.add(k);//
             }
        }
        
        class Factory extends Thread{ //生产任务的线程，总共会生产10个任务
            public void run() {
                for(int i=0;i<10;i++) {
                    synchronized(taskList) {
                        taskList.addLast(new Task(i+1));
                        taskList.notify();
                    }
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        
        public static void main(String[] args) {
            Mythreadpool mythreadpool = new Mythreadpool();
            mythreadpool.pool(); //初始化工人
            Mythreadpool.Factory m= mythreadpool.new Factory();
            m.start();
        }
    }

执行效果：

![885859-20190520164516375-1731512862.png][]

--------------------

**分析jdk中是如何实现线程复用的**

# 线程复用 #

即，如何将放入线程中的诸多任务，在N个线程中执行的。

## ThreadPoolExecutor.execute() ##

public void execute(Runnable command) {
            if (command == null)
                throw new NullPointerException();
            int c = ctl.get();
            if (workerCountOf(c) < corePoolSize) {
                if (addWorker(command, true))
                    return;
                c = ctl.get();
            }
            if (isRunning(c) && workQueue.offer(command)) {
                int recheck = ctl.get();
                if (! isRunning(recheck) && remove(command))
                    reject(command);
                else if (workerCountOf(recheck) == 0)
                    addWorker(null, false);
            }
            else if (!addWorker(command, false))
                reject(command);
        }

分析：可以看出：ThreadPoolExecutor.execute()的功能就是：
    1、将任务添加至阻塞队列workQueue，workQueue.offer(command)
    2、根据core和maxPool，选择是否创建Worker，addWorker()

因此，线程复用的实现应该在worker中，打开addWorker()方法观察

## addWorker ##

private boolean addWorker(Runnable firstTask, boolean core) {
                    //创建worker
            retry:
            for (;;) {
                int c = ctl.get();
                int rs = runStateOf(c);
    
                // Check if queue empty only if necessary.
                if (rs >= SHUTDOWN &&
                    ! (rs == SHUTDOWN &&
                       firstTask == null &&
                       ! workQueue.isEmpty()))
                    return false;
    
                for (;;) {
                    int wc = workerCountOf(c);
                    if (wc >= CAPACITY ||
                        wc >= (core ? corePoolSize : maximumPoolSize))
                        return false;
                    if (compareAndIncrementWorkerCount(c))
                        break retry;
                    c = ctl.get();  // Re-read ctl
                    if (runStateOf(c) != rs)
                        continue retry;
                    // else CAS failed due to workerCount change; retry inner loop
                }
            }
                    //启动worker
            boolean workerStarted = false;
            boolean workerAdded = false;
            Worker w = null;
            try {
                w = new Worker(firstTask);
                final Thread t = w.thread;
                if (t != null) {
                //ThreadExecutor的全局锁，在创建\销毁worker工作池的时候，才会用到
                    final ReentrantLock mainLock = this.mainLock;
                    mainLock.lock();
                    try {
                        // Recheck while holding lock.
                        // Back out on ThreadFactory failure or if
                        // shut down before lock acquired.
                        int rs = runStateOf(ctl.get());
    
                        if (rs < SHUTDOWN ||
                            (rs == SHUTDOWN && firstTask == null)) {
                            if (t.isAlive()) // precheck that t is startable
                                throw new IllegalThreadStateException();
                            workers.add(w);
                            int s = workers.size();
                            if (s > largestPoolSize)
                                largestPoolSize = s;
                            workerAdded = true;
                        }
                    } finally {
                        mainLock.unlock();
                    }
                    if (workerAdded) {
                        t.start();
                        workerStarted = true;
                    }
                }
            } finally {
                if (! workerStarted)
                    addWorkerFailed(w);
            }
            return workerStarted;
        }

分析：addworker分为两部分：1、创建worker，2、启动worker
    规则校验：
    与core和maxPool数量的规则相同
    创建worker：
    获取ThreadLocal的全局锁。 安全的创建Worker。
    t.start();

因此：重点又回到了Worker的run方法上

## Worker.run() ##

public void run() {
                runWorker(this);
    }
    final void runWorker(Worker w) {
            Thread wt = Thread.currentThread();
            Runnable task = w.firstTask;
            w.firstTask = null;
            w.unlock(); // allow interrupts
            boolean completedAbruptly = true;
            try {
                while (task != null || (task = getTask()) != null) {
                    w.lock();
                    // If pool is stopping, ensure thread is interrupted;
                    // if not, ensure thread is not interrupted.  This
                    // requires a recheck in second case to deal with
                    // shutdownNow race while clearing interrupt
                    if ((runStateAtLeast(ctl.get(), STOP) ||
                         (Thread.interrupted() &&
                          runStateAtLeast(ctl.get(), STOP))) &&
                        !wt.isInterrupted())
                        wt.interrupt();
                    try {
                        beforeExecute(wt, task);
                        Throwable thrown = null;
                        try {
                            task.run();
                        } catch (RuntimeException x) {
                            thrown = x; throw x;
                        } catch (Error x) {
                            thrown = x; throw x;
                        } catch (Throwable x) {
                            thrown = x; throw new Error(x);
                        } finally {
                            afterExecute(task, thrown);
                        }
                    } finally {
                        task = null;
                        w.completedTasks++;
                        w.unlock();
                    }
                }
                completedAbruptly = false;
            } finally {
                processWorkerExit(w, completedAbruptly);
            }
        }

分析：这里就比较清晰了：
    1、通过getTask()方法，获取待执行的任务。
    2、通过task.run();执行具体的任务。
    3、正常情况，只有当所有任务执行完毕才会停止运行。

因此：  
　　1、进一步分析getTask()  
　　2、执行task.run()方法。-->>这里可以看出，事实上线程在执行任务的时候，本质上是调用了任务自身的run/call方法。

==》》有点像是thread.get(threadlocal) 本质上是调用了 threadlocalMap.get(thread) 的感觉

## getTask() ##

private Runnable getTask() {
            boolean timedOut = false; // Did the last poll() time out?
    
            for (;;) {
                int c = ctl.get();
                int rs = runStateOf(c);
    
                // Check if queue empty only if necessary.
                if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                    decrementWorkerCount();
                    return null;
                }
    
                int wc = workerCountOf(c);
    
                // Are workers subject to culling?
                boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
    
                if ((wc > maximumPoolSize || (timed && timedOut))
                    && (wc > 1 || workQueue.isEmpty())) {
                    if (compareAndDecrementWorkerCount(c))
                        return null;
                    continue;
                }
    
                try {
                    Runnable r = timed ?
                        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                        workQueue.take();
                    if (r != null)
                        return r;
                    timedOut = true;
                } catch (InterruptedException retry) {
                    timedOut = false;
                }
            }
        }

分析：也不用把代码完全细节完全深究，可以发现方法是从workQueue中获取task的，所以最终的问题就是看这个变量workQueue是谁的成员变量。

public class ThreadPoolExecutor extends AbstractExecutorService {
        private final BlockingQueue<Runnable> workQueue;
        。。。
    }

分析，getTask是从线程池中，获取的任务。即所有的任务都放在ThreadPoolExecutor中，线程池启动多个Worker去执行任务，每个worker不停的从ThreadPoolExector的workQueue中取出任务，比你高执行task.run()方法，直至所有的任务执行完毕。

至此分析完毕。

资料出处：

https://blog.csdn.net/yinni11/article/details/81348210

https://www.jianshu.com/p/93c26498a3c5

https://blog.csdn.net/qq\_38966984/article/details/80415736

转载于:https://www.cnblogs.com/myseries/p/10895078.html

[885859-20190520161447031-441783867.png]: /images/20211214/abab8225f89a4739863234ea4da6fe87.png
[885859-20190520161650426-1078862332.png]: /images/20211214/53b47642451c4c9eb8d906b21d52856c.png
[885859-20190520162408345-2067486896.png]: /images/20211214/078fc667ed814cbf9060adaa6e5de937.png
[885859-20190520162644781-40729645.png]: /images/20211214/19bee7ecfe2e4a688db2cab4511f07c9.png
[885859-20190520162804534-704381292.png]: /images/20211214/dedf51377cb44971aff5295ba3a29e87.png
[885859-20190520163253939-345303126.png]: /images/20211214/136f0d1b79974fca8d8e3ef24a0e247f.png
[885859-20190520163322803-390276509.png]: /images/20211214/c5e91a2ab4f248e2a6562240831cfd03.png
[885859-20190520163350180-34212698.png]: /images/20211214/1a99e7b7e47148299d7a5e725c44e591.png
[885859-20190520164516375-1731512862.png]: /images/20211214/2b1b9dae5dc74efea765812f6f762163.png