JAVA线程池

在学习线程之前需要先明确两点：

1. 每一个线程，在某一时间段内只会执行一个任务

2. 线程池中的线程是可以重复使用的

五种类型线程池的创建方式

1. Executor.newSingleThreadExecutor():创建只有一个线程的线程池（SingleThreadPool）如果往该线程池中提交多个任务，那么这些任务将会被同一个线程顺序执行

2. Executors.newCachedThreadPool()：创建可以存放多个线程的线程池（CachedThreadPoll）,这些线程可以同时执行，默认情况下，如果某个线程的空闲时间超过60s，那么此线程会被终止运行并从池中删除

3. Executors.newFixedThreadPool(线程数)：创建拥有固定线程数的线程池，既然池中的线程数是固定的，那么即使某个线程长时间没有任务执行，那么也会一直等待，不会从池中删除，一般情况下，线程数应该和本级CPU的核数保持一直或整数倍，获取本级的CPU的核数的代码是Runtime.getRuntime().availableProcessors()

4. Executors.newSingleThreadScheduledExecutor()：创建一个可用于任务调度的线程池，并且池中只有一个线程，任务调度是指可以让任务在用户指定的时间执行

5. Executors.newScheduledThreadPool()：创建一个可用于任务调度的线程池，并且池中有多个线程

以上创建的线程池可以大致分为两类，分别是ExecutorService线程池和ScheduledExecutorService线程池，其中ScheduledExecutorService继承ExecutorService

ExecutorService线程池

ExecutorService线程池 可以通过submit（）方法想ExecutorService中提交Callable或者Runable类型的线程任务，任务提交后就会被线程池中的线程领取并执行。线程执行完毕后，会将结果返回到Future对象中，具体提交如下 如果提交的是Callable类型的线程任务，线程通过callable中的call方法执行任务，并用future对象接收call方法的返回值 如果提交的是Runable类型的线程任务，线程通过Runable中的run方法执行任务，而run方法没有返回值，因此Future接收的值是NULL shutDown和shutdownNow是用于关闭线程池的方法，区别如下 shutDown方法将线程池里立刻变成shutdown状态，此时不能再往线程池中增加任务，否则抛出RejectedExecutionException异常，但是shutdown执行后，线程池不会立刻退出，而是会等待线程池中已有的任务全部处理完毕后在推出（即线程池中的所有线程执行完毕后，才会退出） shutdownNow 将线程池的状态乐可变成stop状态，立刻停止所有正在执行的线程，并且不再处理等待队列的任务，这些任务会以List<Runable>的形式，保存在返回值中

ScheduledExecutorService线程池

可以通过schedule()方法向ScheduledExecutorService中提交Callable或者Runable类型的线程任务，特殊的是，用户可以设置次线程池中的任务的执行时间

线程池的使用步骤

1. 创建线程池

2. 使用submit或者schedule提交到线程池中的线程

3. 线程通过run（）或call()方法执行任务，并将任务返回Future对象

4. Future通过get()方法以闭锁的方式获取真实处理后的返回值

案例：创建固定数量的线程池

//创建固定数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(6);
        List<Future<Integer>> futureList=new ArrayList<>();
        for(int i=0;i<6;i++){
            Future<Integer> res = executorService.submit(() -> {
               int sum=0;
                for (int j = 0; j <=10 ; j++) {
                    sum+=j;
                }
                return sum;
            });
            futureList.add(res);
        }

        for(Future<Integer> stringFuture:futureList){
            try {
                //判断线程是否完成
                System.out.println(stringFuture.isDone());
                //获取返回值
                System.out.println(stringFuture.get());

            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }finally {
                executorService.shutdown();
            }
        }
        System.out.println("全部执行完毕");

线程池的流程控制案例

1. 向线程池提交两个任务，每个任务依次执行以下操作：记录当前线程的启动时间，随机休眠2秒内，打印当前线程名，返回当前线程名

2. 这两个任务不会立刻执行，而是等待一段时间（3S）后再执行

3. 在本程序中，main线程会尝试获取这两个线程的结果，如果这两个子电池还没执行完则提示未完成，否则提示已完成并打印线程的返回值

public class ThreadTask implements Callable<String> {
    private String tname;

    @Override
    public String call() throws Exception {
        //获取当前线程的名字
        String name=Thread.currentThread().getName();
        long currentTimeMillis=System.currentTimeMillis();
        System.out.println("线程"+tname+"启动时间"+currentTimeMillis);
        Thread.sleep((long)Math.random()*2000);
        System.out.println(name+"---"+tname+"正在执行");
        return name+"===="+tname;
    }

    public ThreadTask(String name){
        this.tname=name;
    }
}


class TestPool{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Future<String> res=null;
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors());

        List<Future<String>> result=new ArrayList<>();

        for (int i = 0; i <2 ; i++) {
            res=scheduledExecutorService.schedule(new ThreadTask("thread"+i), (long) 3, TimeUnit.SECONDS);
            result.add(res);
        }

        for (Future<String> stringFuture:result){
            System.out.println(stringFuture.isDone()?"已完成":"未完成");
            System.out.println("线程执行完毕，返回的结果："+stringFuture.get());
        }
        scheduledExecutorService.shutdown();
    }
}

运行结果:

image-20210627093241410.png

运行结果分析：

1. 如果TaskCallable线程还没有执行玩不，主线程就去执行res.isDone(),则会显示未完成

2. 之后两个子线程先后启动执行

3. 其中一个子线程执行完毕后返回结果

4. 当第二个子线程执行完毕后，会显示已完成，并打印返回结果

自定义线程池的构建原理与案例详解

可以通过ThreadPoolExecutor的构造方法来创建一个自定义线程池对象，并且通过execute向池中提交无返回值的任务，或者使用submit(）向池中提交有返回值的任务

image-20210627094608436.png

其中，构造方法中各个参数的含义如下所述：

1. corePoolSize：线程池中核心线程数的最大值，核心线程是指一旦有任务提交，核心线程就会去执行

2. maximumPoolSize:线程池中最多能容纳的线程总数。线程总数=核心线程+非核心线程数。非核心线程是指如果有任务提交，首先会交给核心线程执行，如果核心线程满了再将任务放到workQueue中，如果workQueue也满了才将任务交给非核心线程去执行

3. keepAliveTime:线程中非核心线程的最大空闲时长。如果超过了该时间，空闲的非核心线程就会从线程池中被删除。如果设置了allowCoreThreadTimeOut=true,那么keepAliveTime也会作用于核心线程。

4. unit：keepAliveTime的时间单位

5. workQueue:等待提交到线程池中的任务队列。如果所有的核心线程都在执行，那么新添加的任务就会被添加到这个队列中等待处理；如果队列也满了，线程池就会创建非核心线程去执行这些无法添加到队列中的任务；如果向线程池中提交的任务数量大于maximumPoolSize+workQueue.size()就会出现异常 ，异常的类型取决于构造方法的最后一个参数handler

6. threadFactory:创建线程的方式，一般不用设置，使用默认值即可

7. handler：拒绝策略。当向线程提交的任务已满，如何拒绝超额的任务，拒绝策略的上级接口是RejectedExecutionHandler，该接口中定义了拒绝时执行的方法rejectedExecution,源码如下

   
   image-20210627095935618.png

该接口的四个实现类，也就是有4种默认的拒绝策略，分别如下：

• AbortPolicy:默认的拒绝策略，如果已经饱和，就丢掉超额的任务，并抛出RejectedExecutionException异常

• DiscardPolicy:如果饱和，丢掉超额的任务，但不会抛出异常

• DiscardOldestPolicy:队列是FIFO的结构，当采用此策略时，如果已经饱和就删除最早进入队列的任务，再将新任务追加到队尾

• CallerRunsPolicy:如果饱和，新任务就不会去尝试添加到workQueue中，而是直接去调用execute()，是一种“急脾气”的策略，比如排队的时候遇到很多人排就直接插队到最前。

此外，还可以实现RejectedExecutionHandler自定义拒绝策略

public class ThreadMy implements Runnable{
    private String threadName;
    public ThreadMy(String threadName){
        this.threadName=threadName;
    }

    @Override
    public void run() {

        try {
            System.out.println(threadName);
            System.out.println(threadName+"执行了1s");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


class TestMyPool{
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3), new ThreadPoolExecutor.AbortPolicy());
        threadPoolExecutor.execute(new ThreadMy("t1"));
        threadPoolExecutor.execute(new ThreadMy("t2"));
        threadPoolExecutor.execute(new ThreadMy("t3"));
        threadPoolExecutor.execute(new ThreadMy("t4"));
        threadPoolExecutor.execute(new ThreadMy("t5"));
        threadPoolExecutor.execute(new ThreadMy("t6"));
        threadPoolExecutor.shutdown();
    }
}

1. 当只提交t1任务的时候，线程池中正好有一个核心线程，所以t1可以立即执行

2. 当提交t1,t2两个线程的时候，由于核心线程只有一个，所以T1线程会立即执行，t2会进入workQueue等待，等待1s后线程1执行完毕后开始执行

3. 如果提交t1-t4的线程的时候，由于任务队列可以容纳3个线程，所以执行逻辑和第二步一样

4. 当提交t1-t5的时候，由于队列三个已满，此时就会使用非核心线程执行，t5，所以执行顺序是t1,t5,t2,t3,t4

5. 当提交6个线程的时候，由于大于最大线程数（2）+workQueue队列（3），所以会出触发拒策略

此外，也可以使用无界队列，最大线程数只要比核心线程数大就可以