java 线程池（线程的复用）

一. 线程池简介　

1. 线程池的概念：

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

2. 线程池的工作机制

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

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

3. 使用线程池的好处

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

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

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

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

---

二：JDK对线程池的支持

　JDK提供的Executor框架

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

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

　其中常用几类如下：

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类中，我们拿出来一个方法简单分析一下：

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

参数含义如下：

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);
    }
}

运行结果：

　　上述代码，可以看出运行结果为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);
    }
}

运行结果：

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);
    }
}

运行结果：

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();
    }
}

执行效果：

---

分析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