Java多线程初阶-线程池总结

马可波罗.

已于 2023-10-20 21:28:17 修改

阅读量112

点赞数

分类专栏：多线程文章标签： java jvm 开发语言后端

于 2023-04-06 15:23:46 首次发布

本文链接：https://blog.csdn.net/m0_62468521/article/details/129983744

版权

多线程专栏收录该内容

4 篇文章 0 订阅

订阅专栏

newScheduledThreadPool

newSingleThreadExecutor

一、什么是线程池？

线程池是一种管理线程的机制，用于复用线程资源，减少线程创建和销毁的开销，从而提高程序性能；线程池中的线程在完成任务后不会立即销毁，而是被放回线程池，等待执行新的任务

二、线程池参数介绍

ThreadPoolExecutor构造方法：


public ThreadPoolExecutor(int corePoolSize, //核心线程数量
                              int maximumPoolSize,//     最大线程数
                              long keepAliveTime, //       最大空闲时间
                              TimeUnit unit,         //        时间单位
                              BlockingQueue<Runnable> workQueue,   //   任务队列
                              ThreadFactory threadFactory,    // 线程工厂
                              RejectedExecutionHandler handler  //  饱和处理机制
	)

1.核心线程数（corePoolSize）:线程池中始终保持的线程数.当线程池中的线程数小于核心线程数时,即使有空闲线程,新任务也会创建新的线程执行.

2.最大线程数（maximumPoolSize）:线程池中允许的最大线程数.

3.工作队列（workQueue）:用于存储等待执行的任务的阻塞队列。当核心线程数满时，新任务会进入工作队列等待执行。

4.线程空闲时间（keepAliveTime）：当线程池中的线程数大于核心线程数时，多余的空闲线程在等待新任务的最长时间。超过这个时间，空闲线程将被销毁。

5.线程工厂（ThreadFactory）:用于创建新线程的工厂对象。

6.拒绝策略（RejectedExecutionHandler）:当线程池无法处理新任务时采取的拒绝策略.

拒绝策略

1.AbortPolicy（默认）:直接抛出RejectedExecutionException异常,不执行被拒绝的任务

2.CallerRunsPolicy:将被拒绝的任务交给调用线程池的线程（通常是主线程）来执行。这种策略可以降低新任务提交的速度，从而为线程池腾出时间来处理更多任务.

3.DiscardPolicy:当新任务被提交后直接被丢弃掉,不执行也不抛出异常.

4.DiscardOldestPolicy:丢弃工作队列中最旧的任务,然后将新任务添加到工作队列中.如果队列中的任务是有序的或存在依赖关系,这种策略可能导致问题.

三、线程池工作流程

当有新任务提交时,线程池会根据核心线程数创建新线程来执行任务.

如果当前线程数达到核心线程数,新任务会被放入工作队列中.

如果工作队列已满,线程池会创建新线程来执行任务,直到线程数达到最大线程数.

如果线程数已达到最大线程数且工作队列已满,线程池会根据拒绝策略处理新任务.

当线程池中的线程数大于核心线程数且空闲时间超过keepAliveTime时,多余的空闲线程将被销毁.

四、使用Executors创建常见线程池

Java通过Executors工厂类提供四种线程池，分别为：

newCachedThreadPool ：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，否则新建线程。（线程最大并发数不可控制）
newFixedThreadPool：创建一个固定大小的线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool ：创建一个定时线程池，支持定时及周期性任务执行。
newSingleThreadExecutor ：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

newCachedThreadPool

public class CachedThreadPoolTest {

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

        System.out.println("线程任务开始执行");
        executorService.shutdown();
    }

}

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running...");
    }

}

源码：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
        
    }

通过上面的源码我们可以看到，newCachedThreadPool没有核心线程个数，就像一个餐厅，招聘的全是临时工，而且它的非核心线程无上限，每个临时线程空闲时间只存活60秒

执行流程：

1.没有核心线程，直接向 SynchronousQueue 中提交任务

2.如果有空闲线程，就去取出任务执行；如果没有空闲线程，就新建一个

3.执行完任务的线程有 60 秒生存时间，如果在这个时间内可以接到新任务，就可以继续存在，否则就被回收掉了

因为空闲 60 秒的线程就会被终止，长时间保持空闲的 CachedThreadPool 不会占用任何资源。

newFixedThreadPool

public class FixedThreadPoolTest {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        MyRunnable myRunnable = new MyRunnable();
        for (int i = 0; i < 5; i++) {
            executorService.execute(myRunnable);
        }

        System.out.println("线程任务开始执行");
        executorService.shutdown();
    }

}

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running...");
    }

}

源码：

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

我们通过源码可以看到，FixedThreadPool 的核心线程数和最大线程数都是我们可以指定的， keepAliveTime 为 0，也就是多余的空余线程会被立即终止

执行流程：

线程数少于核心线程数，也就是设置的线程数时，新建线程执行任务
线程数等于核心线程数后，将任务加入阻塞队列
由于队列容量非常大，可以一直加
执行完任务的线程反复去队列中取任务执行

FixedThreadPool 主要用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量。

newScheduledThreadPool

public class ScheduledThreadPoolTest {

    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        MyRunnable myRunnable = new MyRunnable();
        for (int i = 0; i < 5; i++) {
            // 参数1:目标对象,参数2:隔多长时间开始执行线程,参数3:执行周期,参数4:时间单位
            scheduledExecutorService.scheduleAtFixedRate(myRunnable, 1, 2, TimeUnit.SECONDS);
        }

        System.out.println("线程任务开始执行");
    }

}

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running...");
    }

}

newSingleThreadExecutor

public class SingleThreadExecutorTest {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        MyRunnable myRunnable = new MyRunnable();
        for (int i = 0; i < 5; i++) {
            executorService.execute(myRunnable);
        }

        System.out.println("线程任务开始执行");
        executorService.shutdown();
    }

}

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running...");
    }

}

马可波罗.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java多线程初阶-线程池总结

public ThreadPoolExecutor(int corePoolSize, //核心线程数量int maximumPoolSize,// 最大线程数long keepAliveTime, // 最大空闲时间TimeUnit unit, // 时间单位BlockingQueue workQueue, // 任务队列ThreadFactory threadFactory, // 线程工厂。
复制链接

扫一扫