Java深入学习：线程池原理

Posted 2022-12-25 xuyiqing

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java深入学习：线程池原理相关的知识，希望对你有一定的参考价值。

线程池的特点：

降低资源：通过重复利用已创建的线程降低线程创建和销毁的损耗

提高效率：当任务到底时，不需要等待，立即执行

方便管理：统一分配，调优和监控等

线程池的创建方式：

1.CachedThreadPool：创建一个可缓存线程池，灵活回收空闲线程

public class ThreadPoolDemo 
    public static void main(String[] args) 
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) 
            final int temp = i;
            newCachedThreadPool.execute(new Runnable() 
                @Override
                public void run() 
                    System.out.println(Thread.currentThread().getName() + "->" + temp);
                
            );

打印后可以发现：同一个线程有被再次利用，线程池理论大小是无限的

2.FixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);

其他代码不变，打印发现五个线程都在复用

3.ScheduledThreadPool：支持定时性地执行任务

public class ThreadPoolDemo 
    public static void main(String[] args) 
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) 
            final int temp = i;
            newScheduledThreadPool.schedule(new Runnable() 
                @Override
                public void run() 
                    System.out.println(Thread.currentThread().getName() + "->" + temp);
                
            , 3, TimeUnit.SECONDS);

观察打印：等待3s后打印

4.SingleThreadExecutor：单线程

        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

打印发现只调用了一个线程

线程池的原理：

四种方式都走了ThreadPoolExecutor的构造方法：

    public static ExecutorService newSingleThreadExecutor() 
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) 
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);

corePoolSize：最大核心线程数：实际运用线程数

maximumPoolSize：最大线程数：线程池最多创建线程数

如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务

如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；

如果队列已经满了，则在总线程数不大于maximumPoolSize的前提下，则创建新的线程；

如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；

如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

技术图片

写一段代码来理解：

public class MyThreadPool 
    public static void main(String[] args) 
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                //核心线程数为1
                1,
                //最大线程数为2
                2,
                //保持存活时间0毫秒，意思是用完不回收
                0L, TimeUnit.MILLISECONDS,
                //阻塞队列
                new LinkedBlockingQueue<Runnable>(3));
        threadPoolExecutor.execute(new TaskThread("task1"));
        threadPoolExecutor.execute(new TaskThread("task2"));
        threadPoolExecutor.execute(new TaskThread("task3"));
    


class TaskThread implements Runnable 
    private String threadName;

    TaskThread(String threadName) 
        this.threadName = threadName;
    

    @Override
    public void run() 
        System.out.println(threadName);