Java线程池小结

叁歲伎倆 2022-04-10 02:47 133阅读 0赞

1、java.util.concurrent中关于线程池的核心类ThreadPoolExecutor的总结,图1为ThreadPoolExecutor类的一些父子继承关系

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70][]

创建线程池的核心参数解读

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70 1][]

(1)corePoolSize：预创建线程，核心池的大小。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；

(2)maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；

(3)keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

(4)unit：参数keepAliveTime的时间单位;

(5)workQueue ：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue。一般使用LinkedBlockingQueue和Synchronous,LinkedBlockingQueue（无界阻塞队列），队列最大值为Integer.MAX\_VALUE。如果任务提交速度持续大余任务处理速度，会造成队列大量阻塞。因为队列很大，很有可能在拒绝策略前，内存溢出。

(6)threadFactory:线程工厂，主要用来创建线程；

(7)handler：表示当拒绝处理任务，有以下几种取值

![2018122411482234.png][]

2、线程池创建

（1）使用java.util.concurrent包下的Executors类提供的静态方法，创建预定义的线程池

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70 2][]

代码示例：

/**
     * @author wuchengfeng
     */
    public class ApplyMulit {
        private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss", Locale.CHINA);
    
        public static void main(String[] args) {
            newMyFixThreadPool();
        }
    
    
        /**
         * jdk自带的线程池创建方式
         * Executors
         */
        private static void newMyFixThreadPool() {
            ExecutorService executorService = Executors.newFixedThreadPool(4);
            MyRunnable myRunnable = new MyRunnable("AAAA");
            MyRunnable myRunnable1 = new MyRunnable("BBBB");
            MyRunnable myRunnable2 = new MyRunnable("CCCC");
            MyRunnable myRunnable3 = new MyRunnable("DDDD");
            for (int i = 0; i < 10; i++) {
                System.out.println("#########################" + i);
                executorService.execute(myRunnable);
                executorService.execute(myRunnable1);
                executorService.execute(myRunnable2);
                executorService.execute(myRunnable3);
            }
        }
    
    
        public static class MyRunnable implements Runnable {
    
            private String threadName;
    
            public String getThreadName() {
                return threadName;
            }
    
            public void setThreadName(String threadName) {
                this.threadName = threadName;
            }
    
            @Override
            public String toString() {
                return "MyRunnable=" + threadName;
            }
    
            MyRunnable(String threadName) {
                this.threadName = threadName;
            }
    
            @Override
            public void run() {
                try {
                    System.out.println(sdf.format(new Date()) + "---create--" + this.toString());
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
        }
    
    }

总共12个线程,单个线程执行耗时3s,如果不使用线程池，串行执行的阻塞时间为36s;如果使用线程池，线程池并发处理4个线程，那么串行执行的阻塞时间为6s，大大提高了效率：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70 3][]

（2）自定义线程池

public class ApplyMulit {
        private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss", Locale.CHINA);
        private static  int  i=0;
        public static void main(String[] args) {
            //newMyFixThreadPool();
            getThreadPool();
        }
    
    
        /**
         * 自定义线程工厂
         */
        public static class ThreadFactoryBuilder implements ThreadFactory {
            private AtomicInteger thread = new AtomicInteger(1);
            @Override
            public Thread newThread(Runnable runnable) {
                String s ="ThreadFactoryBuilder#######"+thread.toString();
                System.out.println(">>>>>>>>>>>>>>>>>>>s="+s);
                return new Thread(runnable, s);
            }
        }
    
        /**
         * 自定义拒绝策略
         */
        public static class MyHandler extends ThreadPoolExecutor.CallerRunsPolicy {
            @Override
            public void rejectedExecution(Runnable runnable, ThreadPoolExecutor threadPoolExecutor) {
                super.rejectedExecution(runnable, threadPoolExecutor);
                showRejectPolicy(runnable, threadPoolExecutor);
            }
            void showRejectPolicy(Runnable runnable, ThreadPoolExecutor threadPoolExecutor) {
                System.out.println("***runnable=" + runnable.toString() + "###threadPoolExecutor=" + threadPoolExecutor.toString());
            }
        }
    
        /**
         * 线程业务实现
         */
        public static class MyRunnable implements Runnable {
            private String threadName;
            @Override
            public String toString() {
                return "MyRunnable=" + threadName;
            }
            MyRunnable(String threadName) {
                this.threadName = threadName;
            }
            @Override
            public void run() {
                try {
                    System.out.println(sdf.format(new Date()) + ">>>>create>>>>i="+(i++)+ ">>>>>"+ this.toString());
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        private static  void getThreadPool(){
           //线程总数的设置：对于cpu密集型的业务，可采用公式：cpu核磁数x每核线程数+1;对于io密集型的的，而可采用公式：cpu核磁数x每核线程数x修正系数r(50<r<100)
            ThreadPoolExecutor  pool=new ThreadPoolExecutor(4,12,30, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(128),new ThreadFactoryBuilder(),new MyHandler());
             //允许核心线程回收
             pool.allowCoreThreadTimeOut(true);
            MyRunnable myRunnable = new MyRunnable("AAAA");
            MyRunnable myRunnable1 = new MyRunnable("BBBB");
            MyRunnable myRunnable2 = new MyRunnable("CCCC");
            MyRunnable myRunnable3 = new MyRunnable("DDDD");
            for(int  i=0;i<20;i++){
                pool.execute(myRunnable);
                pool.execute(myRunnable1);
                pool.execute(myRunnable2);
                pool.execute(myRunnable3);
            }
        }
    }

（3）线程池的生命周期

Running：能接受新任务以及处理新添加的任务

Shutdown:不能接受新任务，可以处理已经添加任务

Stop：不接受新任务，不处理已经添加的任务，并且中断正在处理的任务

Tidying: 所有的任务已经终止，ctl记录的“任务数量”为0,ctl负责记录线程的运行状态与活动的线程数量

Terminated: 线程池彻底终止，则线程转化为terminated状态

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70 4][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70]: /images/20220403/eb2e82ef6eda4e6e9ae4fb6ba827dc30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70 1]: /images/20220403/d3604da861c04c62b59bdcf1a2914018.png
[2018122411482234.png]: /images/20220403/44836c8036d94c5fa0e6951bdb19d1bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70 2]: /images/20220403/69a3e362fe3e4013baf5884295c393cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70 3]: /images/20220403/333dd666f8e7497daf429429ca39be4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdjaGVuZ3d1MjAxMg_size_16_color_FFFFFF_t_70 4]: /images/20220403/031bf6a5e39c4bc3902554073fd72bd2.png