22、线程池

 

一、为什么需要线程池

▪ 在实际使用中，线程是很占用系统资源的，如果对线程管理不善

　　很容易导致系统问题。因此，在大多数并发框架中都会使用线程

　　池来管理线程，使用线程池管理线程主要有如下好处：

　　– 1、使用线程池可以重复利用已有的线程继续执行任务，避免线程在创建和

　　　　销毁时造成的消耗

　　– 2、由于没有线程创建和销毁时的消耗，可以提高系统响应速度

　　– 3、通过线程可以对线程进行合理的管理，根据系统的承受能力调整可运行

　　　　线程数量的大小等

 任务其实就是写的代码，提交任务就是代码逻辑，是需要线程来运行的

从线程池里面拿取数据，里面有具体的执行过程

核心线程池：开始无法预估系统， 假如预设值30个，不管有没有用户的连接，就保持30个，这就是核心线程池的数量

　　根据业务需求，并发访问量决定就好

阻塞队列：只有30个线程，但是同一时刻提交了300个任务，不可能同时执行300个，先执行30个，剩下的270个放在任务队列中

线程池：比如有个水缸，平常只放半缸水就好，它里面有一个max最大容量，最大容量如果没满就创建线程执行任务

饱和策略又叫拒绝策略

 

▪ 线程池执行所提交的任务过程：

▪ 1、先判断线程池中核心线程池所有的线程是否都在执行任务。

　　如果不是，则新创建一个线程执行刚提交的任务，否则，核心线

　　程池中所有的线程都在执行任务，则进入第2步；

▪ 2、判断当前阻塞队列是否已满，如果未满，则将提交的任务放

　　置在阻塞队列中；否则，则进入第3步；

▪ 3、判断线程池中所有的线程是否都在执行任务，如果没有，则

　　创建一个新的线程来执行任务，否则，则交给饱和策略进行处理

二、线程池的分类

ThreadPoolExecutor：线程池执行器

ScheduledThreadPoolExecutor：可调度的线程池执行器

ForkJoinPool：JDK1.7后新出现的，分组组合， 分而治之

　　1-100的和 50*101=5050

1、ThreadPoolExecutor newCachedThreadPool(无界)

 

public class CacheThreadPoolDemo {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i = 0;i<20;i++){
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }

}

public class Task implements Runnable {
    @Override
    public void run() {
//        try {
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println(Thread.currentThread().getName()+" running");
    }
}

打印结果为：

 会出现线程的重用， 加个睡眠会发现创建了20个线程

 这里面没见到start，是因为是线程池触发的

/*
创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用他们, 并在需要时提供的ThreadFactory创建新线程

特征:
(1) 线程池中数量没有固定, 可达到最大值(Interger, MAX_VALUE) 21亿
(2) 线程池中的线程可进行缓存重复利用和回收(回收默认时间为1分钟)
(3) 当线程池中, 没有可用线程, 会重新创建一个线程
*/

2、ThreadPoolExecutor newFixedThreadPool(指定大小)

public class FixedThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5); // 最多容纳多少个线程
        for (int i = 0 ;i<20;i++){
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
}

打印结果为:

睡眠打开后, 5个一执行

重用指定好的线程池

3、ThreadPoolExecutor newSingleThreadExecutor(单一)

public class SingleThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for(int i = 0;i<20;i++){
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
}

打印结果为:

 为什么有这么多分类???

 这些最终都是执行的ThreadPoolExecutor(), 只是参数不同

最终要学习的就是ThreadPoolExecutor

有定时任务, java里有Timer类 quartz 但是多线程里想操作线程的延时执行必须用调度框架

4、ScheduledThreadPoolExecutor newScheduledThreadPool

3s后执行

public class ScheduledThreadPoolDemo {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        System.out.println(System.currentTimeMillis());
        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟三秒执行");
                System.out.println(System.currentTimeMillis());
            }
        },3, TimeUnit.SECONDS);
        scheduledExecutorService.shutdown();
    }
}

 每3秒执行一次

public class ScheduledThreadPoolDemo2 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        System.out.println(System.currentTimeMillis());
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("1------延迟一秒执行，每三秒执行一次");
                System.out.println(System.currentTimeMillis());
            }
        },1,3, TimeUnit.SECONDS);
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("2------延迟一秒执行，每三秒执行一次");
                System.out.println(System.currentTimeMillis());
            }
        },1,3, TimeUnit.SECONDS);
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("3-------延迟一秒执行，每三秒执行一次");
                System.out.println(System.currentTimeMillis());
            }
        },1,3, TimeUnit.SECONDS);
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("4--------延迟一秒执行，每三秒执行一次");
                System.out.println(System.currentTimeMillis());
            }
        },1,3, TimeUnit.SECONDS);
//        scheduledExecutorService.shutdown();
    }
}

什么样的场景会用到分而治之

1、实例1

import java.util.concurrent.RecursiveAction;

class PrintTask extends RecursiveAction {
    private static final int THRESHOLD = 50; //最多只能打印50个数
    private int start;
    private int end; 
  
    public PrintTask(int start, int end) {
        super();
        this.start = start;
        this.end = end;
    }

    @Override
    protected void compute() {
        
        if(end - start < THRESHOLD){
            for(int i=start;i<end;i++){
                System.out.println(Thread.currentThread().getName()+"的i值："+i);
            }
        }else {
            int middle =(start+end)/2;
            PrintTask left = new PrintTask(start, middle);
            PrintTask right = new PrintTask(middle, end);
            //并行执行两个“小任务”
            left.fork();
            right.fork();
        }
        
    }
    
}

/**
 *
 * 简单的打印0-300的数值。用多线程实现并行执行
 *
 */
public class ForkJoinPoolAction {
    
    public static void main(String[] args) throws Exception{
        PrintTask task = new PrintTask(0, 300);
        //创建实例，并执行分割任务
        ForkJoinPool pool = new ForkJoinPool();
        pool.submit(task);
         //线程阻塞，等待所有任务完成
        pool.awaitTermination(2, TimeUnit.SECONDS);
        pool.shutdown();
    }
}

 不同的worker来执行的, 300个数

300 等分 150下

150 等分 75 下

75 等分 37 38 下

300 - 0 < 50 ? 进入 else

middle 150

left 0 150

right 150 300

就这样一直进行切分

2、实例2

import java.util.concurrent.RecursiveTask;

class SumTask extends RecursiveTask<Integer> {
    private static final int THRESHOLD = 20; //每个小任务 最多只累加20个数
    private int arry[];
    private int start;
    private int end;
    
    

    /**
     * Creates a new instance of SumTask.
     * 累加从start到end的arry数组
     * @param arry
     * @param start
     * @param end
     */
    public SumTask(int[] arry, int start, int end) {
        super();
        this.arry = arry;
        this.start = start;
        this.end = end;
    }



    @Override
    protected Integer compute() {
        int sum =0;
        //当end与start之间的差小于threshold时，开始进行实际的累加
        if(end - start <THRESHOLD){
            for(int i= start;i<end;i++){
                System.out.println(Thread.currentThread().getName()+"的i值："+arry[i]);
                sum += arry[i];
            }
            return sum;
        }else {//当end与start之间的差大于threshold，即要累加的数超过20个时候，将大任务分解成小任务
            int middle = (start+ end)/2;
            SumTask left = new SumTask(arry, start, middle);
            SumTask right = new SumTask(arry, middle, end);
            //并行执行两个 小任务
            left.fork();
            right.fork();
            //把两个小任务累加的结果合并起来
            return left.join()+right.join();
        }
        
    }
    
}

import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;

public class ForJoinPollTask {

    public static void main(String[] args) throws Exception {
        int[] arr = new int[100];
        Random random = new Random();
        int total =0;
        //初始化100个数组元素
        for(int i=0,len = arr.length;i<len;i++){
            int temp = random.nextInt(20);
            //对数组元素赋值，并将数组元素的值添加到sum总和中
            total += (arr[i]=temp);
        }
        System.out.println("初始化数组总和："+total);
        SumTask task = new SumTask(arr, 0, arr.length);
//        创建一个通用池，这个是jdk1.8提供的功能
        ForkJoinPool pool = ForkJoinPool.commonPool();
        Future<Integer> future = pool.submit(task); //提交分解的SumTask 任务
        System.out.println("多线程执行结果："+future.get());
        pool.shutdown(); //关闭线程池
        
        

    }

}

3、实例3

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class newWorkStealingPoolTest {
 
    public static void main(String[] args) throws Exception {
 
        // 设置并行级别为2，即默认每时每刻只有2个线程同时执行
        ExecutorService m = Executors.newWorkStealingPool();
 
        for (int i = 1; i <= 10; i++) {
            final int count=i;
            m.submit(new Runnable() {
                @Override
                public void run() {
                    Date now=new Date();
                    System.out.println("线程" + Thread.currentThread() + "完成任务："
                            + count+"   时间为："+    now.getSeconds());
                    try {
                        Thread.sleep(1000);//此任务耗时1s
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
 
            });
           
        }
        while(true){
            //主线程陷入死循环，来观察结果，否则是看不到结果的
        }
    }
}

三、线程池的生命周期

▪ RUNNING ：能接受新提交的任务，并且也能处理阻塞队列中的任务；

▪ SHUTDOWN：关闭状态，不再接受新提交的任务，但却可以继续处理阻

　　塞队列中已保存的任务。

▪ STOP：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。

▪ TIDYING：如果所有的任务都已终止了，workerCount (有效线程数) 为0，

　　线程池进入该状态后会调用 terminated() 方法进入TERMINATED 状态。

▪ TERMINATED：在terminated() 方法执行完后进入该状态，默认

　　terminated()方法中什么也没有做。

面试：

线程生命周期只有两种状态，RUNNING和TERMINATED，但是在从RUNNING到TERMINATED这个状态过度的时候

会有中间3种状态，第一种调用shutdown()时会切换到SHUTDOWN，第二种调用shutdown Now() 时切换到STOP，

最终会进行一个回收的工作，SHUTDOWN回收时当前正在执行的任务会执行完（阻塞队列为空，线程池中的工作线程数量为0）

进入到TIDYING

STOP队列里有任务也会直接干掉，不是等待执行完再干掉

之前我们说不管哪个分类都调用ThreadPoolExecutor

四、ThreadPoolExecutor

构造方法

 

▪ corePoolSize：核心线程池的大小， 标准池，（公交车正常做17个人）

▪ maximumPoolSize：线程池能创建线程的最大个数 （公交车早晚高峰最大能做57个人）

▪ keepAliveTime：空闲线程存活时间 （临时加了13个座位，多长时间把13个座位撤掉）

▪ unit：时间单位，为keepAliveTime指定时间单位

▪ workQueue：阻塞队列，用于保存任务的阻塞队列 （如果没有要自己维护共享变量，需要有等待和唤醒的过程，就有了GUC）

▪ threadFactory：创建线程的工程类

▪ handler：饱和策略（拒绝策略）

五、拒绝策略

▪ ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

▪ ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

▪ ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

▪ ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务