Java中的线程池

1.什么是线程池

线程池：用于管理线程对象的池子。

2.为什么使用线程池

一个线程大约占用的内存为1M

1.解决频繁创建线程和销毁线程消耗的性能。

2.解决大量创建线程而导致的内存泄露问题。

3.如何创建线程池

java中提供了俩种方式：

第一种：通过工具类Executors完成线程池的创建。（语法简单，但是阿里巴巴不建议使用）

第二种：通过线程池类ThreadPoolExecutor类创建。（语法复杂但灵活，阿里巴巴建议使用）

线程的根接口：Executor。里面只有一个方法：execute。子接口：ExecutorService。

3.1 通过Executors工具类创建

1.固定大小的线程池对象：newFixedThreadPool

2.单一线程池：newSingleThreadExecutor

3.可变线程池：newCachedThreadPool

4.延迟线程池：newScheduledThreadPool

public class Test01 {
    public static void main(String[] args) {
        //创建一个固定大小的线程池。返回类型为ExecutorService.
//        ExecutorService executorService = Executors.newFixedThreadPool(5);
        //创建单一线程池【池子里面只有一个线程的对象】适合任务顺序执行的。
//        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //创建可变线程池。【池子中线程的数量会随着任务的大小而变化】
//        ExecutorService executorService = Executors.newCachedThreadPool();
        //延迟线程池:[指定时间后执行]
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);

        //执行线程任务。Runnable  Callable. Integer.MAX()整数的最大值。
//        for(int i=0;i<10;i++) {
            //1.必须传递Runnable对象。[1]自己创建一个类实现Runnable接口  [2]匿名内部类对象 [3]lambda表达式: 前提接口必须为函数式接口。
//            executorService.execute(new My());
//            executorService.execute(new Runnable() {
//                @Override
//                public void run() {
//                    System.out.println(Thread.currentThread().getName()+"*************");
//                }
//            });
            //表示10秒后执行任务代码块。
//            executorService.schedule(()->{
//                System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~~");
//            },10, TimeUnit.SECONDS);
            executorService.scheduleAtFixedRate(()->{
                System.out.println(Thread.currentThread().getName());
            },5,2,TimeUnit.SECONDS);
//        }

        //关闭线程池



    }
}

execute和submit的区别：

1.俩个都可以用来执行任务，但是execute属于Executor类种的方法，而submit属于ExecutorService接口种的方法。

2.submit可以执行runnable和callable类型的任务，而execute只能执行Runnable类型的任务。submit执行完任务后有返回结果。

3.2 通过ThreadPoolExecutor类创建

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test02 {
    public static void main(String[] args) {
        //核心参数的意思
        /**
         * int corePoolSize,核心线程数的个数 2
         *  int maximumPoolSize,最大线程数量 5
         * long keepAliveTime, 非核心线程允许空闲的时间
         * TimeUnit unit, 时间的单位
         * BlockingQueue<Runnable> workQueue 堵塞队列中 3
         */
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue(5);
        ThreadPoolExecutor poolExecutor=new ThreadPoolExecutor(2,6,10, TimeUnit.SECONDS,workQueue);

        for (int i = 0; i <11; i++) {
            poolExecutor.submit(()->{
                System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~~~");
            });
        }
    }
}

通过场景理解ThreadPoolExecutor中的各个参数;

1. a客户(任务)去银行(线程池)办理业务,但银行刚开始营业,窗口服务员还未就位(相当于线程池中初始线程数量为0),于是经理(线程池管理者)就安排1号工作人员(创建1号线程执行任务)接待a客户(创建线程);
2.在a客户业务还没办完时,b客户(任务)又来了,于是经理(线程池管理者)就安排2号工作人员(创建2号线程执行任务)接待b客户(又创建了一个新的线程);假设该银行总共就2个窗口(核心线程数量是2);
紧接着在a,b客户都没有结束的情况下c客户来了,于是经理(线程池管理者)就安排c客户先坐到银行大厅的座位上(空位相当于是任务队列)等候,并告知他: 如果1、2号工作人员空出,c就可以前去办理业务;
3.此时d客户又到了银行,(工作人员都在忙,大厅座位也满了)于是经理赶紧安排临时工(新创建的线程)在大堂站着,手持pad设备给d客户办理业务;
4.假如前面的业务都没有结束的时候e客户又来了,此时正式工作人员都上了,临时工也上了,座位也满了(临时工加正式员工的总数量就是最大线程数),于是经理只能按《超出银行最大接待能力处理办法》(饱和处理机制)拒接接待e客户;
5.最后,进来办业务的人少了,大厅的临时工空闲时间也超过了1个小时(最大空闲时间),经理就会让这部分空闲的员工人下班.(销毁线程)但是为了保证银行银行正常工作(有一allowCoreThreadTimeout变量控制是否允许销毁核心线程,默认false),即使正式工闲着,也不得提前下班,所以1、2号工作人员继续待着(池内保持核心线程数量);