Java线程池总结--java几种线程池

四种线程池介绍:

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

各个线程池代码实例

(1).newCachedThreadPool 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程
线程池为无限大,当执行第二个任务时第一个任务已经完成,会复用执行第一个任务的线程,而不用每次新建线程

//为了体验到复用线程效果,每一个线程进行100毫秒*n休眠
public static void main(String[] args) {
    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    for (int i = 0; i < 5; i++) {
        final int index = i;
        try {
            Thread.sleep(index * 100);
        } catch (Exception e) {
            e.printStackTrace();
        }
        cachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(index+" 当前线程"+Thread.currentThread().getName());
            }
        });
    }
}

结果如下:

0 当前线程pool-1-thread-1
1 当前线程pool-1-thread-1
2 当前线程pool-1-thread-1
3 当前线程pool-1-thread-1
4 当前线程pool-1-thread-1

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

//线程池中设置数量为3个,那么只会有三个线程执行10条数据
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    final int index = i;
    fixedThreadPool.execute(new Runnable() {
    	@Override
        public void run() {
            try {
                Thread.sleep(2000);
                System.out.println(index+" 当前线程"+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
}

结果如下:

0 当前线程pool-1-thread-1
1 当前线程pool-1-thread-2
2 当前线程pool-1-thread-3
3 当前线程pool-1-thread-1
4 当前线程pool-1-thread-2
5 当前线程pool-1-thread-3
6 当前线程pool-1-thread-1
7 当前线程pool-1-thread-2
8 当前线程pool-1-thread-3
9 当前线程pool-1-thread-1

(3).newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行
线程池延迟3秒后执行

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
    @Override
    public void run() {
        System.out.println("延迟3秒后执行");
    }
}, 3, TimeUnit.SECONDS);

(4).newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
下面是按照顺序执行FIFO(一般情况下多线程index是乱的,该线程池保证了按照顺序执行)

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
    final int index = i;
    singleThreadExecutor.execute(new Runnable() {
        @Override
        public void run() {
            try {
                System.out.println("--index--"+index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
}

结果如下:

--index--0
--index--1
--index--2
--index--3
--index--4
--index--5
--index--6
--index--7
--index--8
--index--9

重点

1、底层结构实现原理:是基于阻塞队列实现

  • newCachedThreadPool 默认是用SynchronousQueue队列实现
  • newFixedThreadPool 默认是用LinkedBlockingQueue队列实现
  • newScheduledThreadPool默认是用DelayedWorkQueue队列实现
  • newSingleThreadExecutor默认是用LinkedBlockingQueue队列实现

2、自己构建一个线程池参数有哪些

public ThreadPoolExecutor(int corePoolSize, 
						  int maximumPoolSize, 
						  long keepAliveTime,   
						  TimeUnit unit, 
						  BlockingQueue<Runnable> workQueue );

1、corePoolSize: 核心线程数
2、maximumPoolSize:最大支持线程数
3、keepAliveTime :当线程空闲超过一段时间,线程池会判断:运行的线程数大于 corePoolSize,线程被停掉
4、TimeUnit :过期时间单位
5、workQueue:使用什么队列

例如:

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

3、底层实现原理:

首先调用executor()执行任务,进入线程池,此时线程数还未超过corePoolSize,当线程数超过corePoolSize时,线程会进入阻塞队列等待,当阻塞队列的线程存到一定数量时,线程池会扩容,但不会超过最大线程数,maximumPoolSize,当线程数量超过最大线程数时,线程池会启动拒绝策略,来保证任务正常进行,当任务线程数越来越少时,会逐渐恢复到corePoolSize

4、拒绝策略:

在这里插入图片描述
常用的四种拒绝策略:

  • AbortPolicy 直接抛出RejectedExecutionExeception异常来阻止系统正常运行 默认策略
  • CallerRunsPolicy 将任务回退到调用者
  • DisOldestPolicy 丢掉等待最久的任务‘
  • DisCardPolicy 直接丢弃任务

这四种拒绝策略均实现的RejectedExecutionHandler接口

线程池默认的拒绝行为是AbortPolicy,也就是抛出RejectedExecutionHandler异常,该异常是非受检异常,很容易忘记捕获。如果不关心任务被拒绝的事件,可以将拒绝策略设置成DiscardPolicy,这样多余的任务会悄悄的被忽略。

自定义拒绝策略
实现 RejectedExecutionHandler 接口来实现自己的拒绝策略,如代码所示:
在这里插入图片描述

5、线程存活问题

newCachedThreadPool 默认启用一个线程。默认存活时间60s,如果超过60s第一个线程销毁,重新创建一个新的线程
newSingleThreadExecutor:默认启用一个线程。不过期,自始至终只有一个线程来执行任务
newFixedThreadPool :设置固定核心线程数,有多个核心线程执行任务
newScheduledThreadPool:设置固定核心线程数,有多个核心线程执行任务

ThreadPoolExecutor构造方法

Java中创建线程池很简单,只需要调用 Executors 中相应的便捷方法即可,比如:Executors.newFixedThreadPool(int nThreads),但是便捷不仅隐藏了复杂性,也为我们埋下了潜在的隐患(OOM,线程耗尽)。

小程序使用这些快捷方法没什么问题,对于服务端需要长期运行的程序,创建线程池应该直接使用 ThreadPoolExecutor 的构造方法。

Executors中创建线程池的快捷方法,实际上是调用了ThreadPoolExecutor的构造方法(定时任务使用的是ScheduledThreadPoolExecutor),该类构造方法参数列表如下:

// Java线程池的完整构造函数
public ThreadPoolExecutor(
  int corePoolSize, // 线程池长期维持的线程数,即使线程处于Idle状态,也不会回收。
  int maximumPoolSize, // 线程数的上限
  long keepAliveTime, TimeUnit unit, // 超过corePoolSize的线程的idle时长,
                                     // 超过这个时间,多余的线程会被回收。
  BlockingQueue<Runnable> workQueue, // 任务的排队队列
  ThreadFactory threadFactory, // 新线程的产生方式
  RejectedExecutionHandler handler) // 拒绝策略

这些参数中,比较容易引起问题的有corePoolSize, maximumPoolSize, workQueue以及handler:

  • corePoolSize和maximumPoolSize 设置不当会影响效率,甚至耗尽线程;
  • workQueue 设置不当容易导致OOM;
  • handler 设置不当会导致提交任务时抛出异常。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值