【多线程】线程池

前言

多线程的出现是为了优化多进程，优化进程创建、销毁的开销；而随着计算机技术的发展，人们又进一步优化多线程，提前创建线程减少多线程的开销，让程序更快更轻量。于是线程池诞生了，根据需求提前创建一堆线程，里面的线程也可以复用，减少创建销毁的内存开销，将创建和使用线程的步骤分开既减少了代码耦合度，也方便统一管理线程。线程池的实现（依靠ThreadPoolExecutor）开发者也是可以自定义的，包括池里线程的数量、池满的策略、单个线程的具体属性。

实现线程池的两种方式

Executor将线程池这一概念抽象出来，ExecutorService继承Executor接口，抽象类AbstractExecutorService类实现ExecutorService接口，ThreadPoolExecutor继承AbstractExecutorService，而最终通过ThreadPoolExecutor来实现线程池。

Java可以通过Executors工厂类的静态方法和ThreadPoolExecutor实现线程池。ThreadPoolExecutor高度自由化，可以通过最多7个参数来自定义线程池，而Executors是对ThreadPoolExecutor的封装，Executors实现了几种常见的线程池，并对外提供了静态方法用于获取线程池实例。所以线程池的最底层就是ThreadPoolExecutor类。

ThreadPoolExecutor

“任务”概念：Runnable类的run()方法主体内容

//构造方法
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler){}

当向线程池提交一个任务时触发了拒绝策略：

为了方便理解线程池的逻辑，这里模拟了一个简化版线程池方便理解：

import java.util.concurrent.ArrayBlockingQueue;

class MyThreadPool{
    private ArrayBlockingQueue<Runnable> queue=null;
    //n为核心线程数
    public MyThreadPool(int n){
        queue=new ArrayBlockingQueue(100);//队列最多任务数
        for (int i = 0; i < n; i++) {
            //内部定义一个线程来取出队列里的任务并执行
            Thread t = new Thread(() -> {
                try {
                    while (true) {
                        Runnable task = queue.take();
                        task.run();
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }

    }
    //提交任务到线程池里也就是工作队列里
    public void submit(Runnable task) throws InterruptedException {
        queue.put(task);
    }
}
class DemoThreadPool {

	public static void main(String[] args) throws InterruptedException {
	        MyThreadPool pool=new MyThreadPool(100);
	        for (int i = 0; i < 100; i++) {
	            int id=i;
	            pool.submit(()->{
	                System.out.println(Thread.currentThread().getName()+" id="+id);
	            });
	
	        }
	    }
}

结果：

在这里插入代码片

通过Executors静态方法

通过Executors静态方法创建线程池，以下方法返回值类型ExecutorService（实际上返回了一个实现ExecutorService接口的类的实例）（newScheduledThreadPool除外，返回值类型是ScheduledExecutorService（实际上返回了一个实现ExecutorService接口的类的实例），ScheduledExecutorService也是一个接口，继承了ExecutorService接口）。

使用newFixedThreadPool()替代上面的示例，效果类似：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService pool= Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            int j=i;
            //提交一个匿名Runnable类对象
            pool.submit(()->{
                System.out.println(Thread.currentThread().getName()+" i= "+j);
            });
        }
    }
}

Executors创建线程池的缺陷

由于Executors静态方法返回的是一个现成的线程池，它不能百分百的适配实际的开发需求和任务需要。例如：

• newFixedThreadPool()和newSingleThreadExecutor()里的工作队列长度允许最大为Integer.MAX_VALUE，很有可能会被添加过多的任务，导致内存溢出；
• newCachedThreadPool()和newScheduledThreadPool()，允许最大创建Integer.MAX_VALUE个线程，可能被发生大量线程被创建的情况，导致内存溢出。
  因此，最好使用ThreadPoolExecutor来创建线程池，这样线程数目、队列满情况处理、拒绝策略等也是可控的。
  最后，线程池里的线程都是前台线程，因此，上面两个示例程序在100层for循环任务结束后程序并未结束而是进入WATTING状态，线程池Running。想结束线程池，可以使用线程池对象调用三种方法：

完。