线程池的参数和线程池的工作原理及其使用Executors框架创建四种线程池

你的名字 2022-10-17 11:13 208阅读 0赞

线程池的参数和线程池的工作原理及其使用Executors框架创建四种线程池作为面试的高频题，现整理如下：

import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 线程池的参数和线程池的工作原理及其使用Executors框架创建四种线程池
     *
     * corePoolSize:线程池保留的最小线程数。如果线程池中的线程少于此数目，则执行execut()时创建。
     * maximumPoolSize:线程池中允许拥有的最大线程数。
     * keepAliveTime、unit:当线程闲置时，保持线程存活的时间。默认情况下，只有当线程池中的线程数大于corePoolSize，才起作用
     * threadFactory:线程工厂类
     * workQueue：工作队列，存放提交的等待任务，其中有队列大小的限制。
     * ArrayBlockingQueue:一个有数组结构组成的有界阻塞队列
     * LinkedBlockingQueue：一个由链表组成的有界阻塞队列，而在未指明容量时，容量默认为Integer.MAX_VALUE.
     * linkedBlockingDeque:使用双向队列实现的双端阻塞队列，双端意味着可以像普通队列一样先进先出，也可以像栈一样后进先出
     * PriorityBlockingQueue：一个支持有线及排序的无界阻塞队列，对元素没有要求，可以实现compareable接口，也可以提供Comparator来对
     * 队列中的元素进行比较，跟时间没有任何关系，紧急按照优先级去任务。
     * DelayQueue：同PriorityBlockingQueue,也是二叉树实现的优先级阻塞队列。要求元素实现delayed接口，通过执行延时队列提出任务，没有
     * 到时间任务取不出来
     * SynchronousQueue：一个不存储元素的阻塞队列，消费者线程调用take()方法的时候就会发生阻塞，只到有一个生产者线程生产了一个元素
     * 消费者线程就可以拿到这个元素并返回；生产者线程调用put()方法的时候也会被阻塞，直到有一个消费者线程消费了这个元素，生产者才会返回。
     *
     * 线程池的工作原理：
     * 1、如果当前运行的线程数少于corePoolSize(核心线程数)，则创建新线程来执行任务
     * 2、如果运行的线程等于或者多于corepoolsize，则将任务加入BlockingQueue
     * 3、如果无法将任务加入Blockingqueue(队列已满)，则在非corePool中创建新的线程来处理任务。
     * 4、如果创建新此案城将是当前运行的线程超出了maximumPoolSize，任务将被拒绝，并执行任务饱和策略。
     *
     *
     * 使用Executors框架创建四种线程池
     * 1、newCachedTheadPool：创建一个可缓存线程池，如果线程池长度超过处理需求，可以灵活回收空闲线程，若无可回收，则新建线程。
     * 线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
     * 2、newFixedThreadPool:创建一个定长线程池，可以控制线程的最大并发数，超出的此案城会在队列中等待。定长线程池的大小最好根据系统
     * 资源进行设置
     * 3、newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。
     * 4、newSingleThreadExecutor:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。
     *
     */
    public class TestThreadPoolExecutor { 
        //创建一个可重用固定个数的线程池
        private static ThreadPoolExecutor fixedThreadPool =new ThreadPoolExecutor(1,2,0L, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<>(1));
    
    
    
        public static void main(String[] args) { 
            fixedThreadPool.execute(new Runnable() { 
                @Override
                public void run() { 
                    try{ 
                        Thread.sleep(500);
                    }catch (InterruptedException e){ 
                        e.printStackTrace();
                    }
                }
            });
            printCount();
            System.out.println("加入第一个任务，线程池刚刚初始化，没有任何可以执行的任务的核心线程，创建一个核心线程来执行任务");
    
            fixedThreadPool.execute(new Runnable() { 
                @Override
                public void run() { 
                    try { 
                        Thread.sleep(500);
                    }catch (InterruptedException e){ 
                        e.printStackTrace();
                    }
                }
            });
    
            printCount();
            System.out.println("加入第二个任务，没有可以执行任务的核心线程，且任务数大于corepoolsize，新加入的任务放在阻塞队列中");
    
            fixedThreadPool.execute(new Runnable() { 
                @Override
                public void run() { 
                    try { 
                        Thread.sleep(1500);
                    }catch (InterruptedException e){ 
                        e.printStackTrace();
                    }
                }
            });
            printCount();
            System.out.println("加入第三个任务，此时阻塞队列已经满了，新建非核心线程执行新加入任务");
    
            try { 
                Thread.sleep(600);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            printCount();
            System.out.println("第一个任务执行完毕，核心线程空闲，阻塞队列的任务被取出来，使用核心线程来执行");
    
            try { 
                Thread.sleep(600);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            printCount();
            System.out.println("第二个任务执行完毕，核心线程空闲，非核心线程在执行第三个任务");
    
            try { 
                Thread.sleep(600);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            printCount();
            System.out.println("第三个任务执行完毕，非核心线程被销毁，核心线程保留");
        }
    
        private static void printCount(){ 
            System.out.println("=============");
            System.out.println("当前活跃线程数"+fixedThreadPool.getActiveCount());
            System.out.println("当前核心线程数"+fixedThreadPool.getCorePoolSize());
            System.out.println("阻塞队里中的任务数"+fixedThreadPool.getQueue().size());
        }
    }