ThreadPoolExecutor和Executors

最新推荐文章于 2024-04-12 11:34:06 发布
最新推荐文章于 2024-04-12 11:34:06 发布
阅读量1.1k 收藏 3
点赞数 2
分类专栏： 并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43430343/article/details/120808594
版权

1、ThreadPoolExecutor

image-20211012172515750

1）线程池状态

ThreadPoolExecutor使用int的高3位来表示线程池状态，低29位表示线程数量

image-20211012172716188

image-20211012173055460

1.线程池的五种状态，只能由小到大迁移,即-1>0>1>2>3。

2.shutdown(不清空任务队列、 会等它们完成，shutdownNow)会清 空任务队列、不等它们完成。shutdown()只中断空闲的线程，shutdownNow()会 中断所有的线程，不管你执行没执行完。

3.TIDYING 和TREMINATED二者之间执行了一个钩子函数terminated(，目前这是-个空的实现。

为了保证线程状态和线程数量赋值操作的原子性，所以将两者存储在同一个原理变量中，用一次cas操作进行赋值

2）构造方法


public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
  • corePoolSize 核心线程数目(最多保留的线程数)
  • maximumPoolSize 最大线程数目
  • keepAliveTime 生存时间-针对救急线程
  • unit 时间单位-针对救急线程
  • workQueue 阻塞队列
  • threadFactory 线程工厂- 可以为线程创建时起个好名字
  • handler 拒绝策略

工作方式

核心线程和救急线程都是懒惰式创建，节约资源，使用的时候才创建

image-20211012173938109

当核心线程都在执行任务，会将新加入的任务梵高阻塞队列中，当阻塞队列也满了，才会使用救急线程

image-20211012174329313

  • 救急线程和核心线程的区别就是，救济线程有生存时间，当任务执行完之后，在生存时间之内没有任务再执行，救急线程就会被销毁。

  • 当救急线程也不够用于执行任务时，才会使用拒绝策略。当队列选择的是有界队列时，那么任务超过了队列大小才会创建救急线程

  • 如果线程到达maximumPoolSize仍然有新任务这时会执行拒绝策略。拒绝策略jdk提供了4种实现,其它著名框架也提供了实现

    • AbortPolicy 让调用者抛出RejectedExecutionException异常,这是默认策略

    • CallerRunsPolicy 让调用者运行任务

    • DiscardPolicy 放弃本次任务

    • DiscardOldestPolicy 放弃队列中最早的任务，本任务取而代之

    • Dubbo 的实现，在抛出RejectedExecutionException异常之前会记录日志，并dump线程栈信息，方便定位问题

    • Netty 的实现，是创建一个新线程来执行任务

    • ActiveMQ的实现，带超时等待(60s) 尝试放入队列，类似我们之前自定义的拒绝策略

    • PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略

      当高峰过去后，超过corePoolSize 的救急线程如果- -段时间没有任务做，需要结束节省资源，这个时间由keepAliveTime和unit来控制。

image-20211012174927792

Executors

1)newFixedThreadPool

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

特点

  • 核心线程数最大线程数(没有救急线程被创建)，因此也无需超时时间

  • 阻塞队列是无界的，可以放任意数量的任务

    评价
    适用于任务量已知，相对耗时的任务

代码:


public static void main(String[] args) {
        ExecutorService pool= Executors.newFixedThreadPool(2);

        pool.execute(()->{
            System.out.println(Thread.currentThread()+"1");
        });
        pool.execute(()->{
            System.out.println(Thread.currentThread()+"2");
        });
        pool.execute(()->{
            System.out.println(Thread.currentThread()+"3");
        });
    }

不会随着主线程的结束而结束

image-20211012182305150

自定义线程工厂–用于命名线程名字

 public static void main(String[] args) {
        ExecutorService pool= Executors.newFixedThreadPool(2, new ThreadFactory() {
            private AtomicInteger t=new AtomicInteger(1);

            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r,"mypool_t"+t.getAndIncrement());
            }
        });

        pool.execute(()->{
            System.out.println(Thread.currentThread()+"1");
        });
        pool.execute(()->{
            System.out.println(Thread.currentThread()+"2");
        });
        pool.execute(()->{
            System.out.println(Thread.currentThread()+"3");
        });
    }

image-20211012182931021

2)newCacheThreadPool

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

特点

  • 核心线程数是0，最大线程数是Integer.MAX_ VALUE,救急线程的空闲生存时间是60s, 意味着

    • 全部都是救急线程(60s 后可以回收)
    • 救急线程可以无限创建

  • 队列采用了SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的(- 手交钱、- -手交货)

评价
整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲1分钟后释放线程。
适合任务数比较密集，但每个任务执行时间较短的情况

3)newSingleThreadExecutor

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

使用场景:
希望多个任务排队执行。线程数固定为1,任务数多于1时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。

区别:

  • 自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池还会新建-个线程,保证池的正常工作
  • Executors.newSingleThreadExecutor() 线程个数始终为1,不能修改
    • FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了ExecutorService 接口，因此不能调用ThreadPoolExecutor中特有的方法
  • Executors.newFixedThreadPool(1)初始时为1,以后还可以修改
    • 对外暴露的是ThreadPoolExecutor对象，可以强转后调用setCorePoolSize 等方法进行修改

提交任务

image-20211014111438851

Callable比Runnable多了返回值，Runnable也不能抛出异常

代码1：

package demo1;

import java.util.concurrent.*;

public class TestSumbit {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Future<String> future=pool.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("running");
                Thread.sleep(1000);
                return "ok";
            }
        });

        System.out.println(future.get());
    }
}

代码2：

package demo1;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;

public class TestSumbit {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        /*Future<String> future=pool.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("running");
                Thread.sleep(1000);
                return "ok";
            }
        });*/
        List<Future<Object>> futures = pool.invokeAll(Arrays.asList(
                () ->{
                        System.out.println(Thread.currentThread() + "begin");
                        Thread.sleep(1000);
                        return "1";
                },
                () ->{
                    System.out.println(Thread.currentThread() + "begin");
                    Thread.sleep(500);
                    return "2";
                },
                () ->{
                    System.out.println(Thread.currentThread() + "begin");
                    Thread.sleep(2000);
                    return "3";
                }

        ));

        futures.forEach(f->{
            try {
                System.out.println(Thread.currentThread()+" "+f.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });

        //System.out.println(future.get());
    }
}

关闭线程

shutdown

线程池状态变为SHUTDOWN
1、不会接收新任务
2、但已提交任务会执行完
3、此方法不会阻塞调用线程的执行

image-20211014140329264

shutdownNow

线程池状态变为STOP
1、不会接收新任务
2、会将队列中的任务返回
3、并用interrupt 的方式中断正在执行的任务
List shutdownNow( );

image-20211014140508137

任务调度线程池

在「任务调度线程池」功能加入之前，可以使用java.util.Timer来实现定时功能，Timer 的优点在于简单易
用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。

image-20211014144206065

代码：

 public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);

        pool.schedule(()->{
            System.out.println(Thread.currentThread()+"task1");
            int i=1/0;
        },1, TimeUnit.SECONDS);

        pool.schedule(()->{
            System.out.println(Thread.currentThread()+"task2");
        },1, TimeUnit.SECONDS);
    }

线程池中只有一个线程，所以线程只能串行运行，但是第一个线程代码出错，并不影响第二个线程的运行

image-20211014150539983

定时执行
pool.scheduleAtFixedRate(): //上个线程开始到下个线程开始延时多长时间（如果线程执行时间大于延时时间，则按照线程执行结束后，立马开始下一个任务）
pool.scheduleWithFixedDelay()：//从上一个线程结束延时指定时间后在执行下一个任务

处理线程池异常

1、任务自己用try块捉住

2、使用submit提交的返回值Future来判断（程序正常执行则返回正常结果，中间有异常则打印异常）

Future<Boolean> f = pool.submit(() -> {
    System.out.println("tsak");
    int i = 1 / 0;
    return true;
});
System.out.println(f.get());

image-20211015145235766

定时执行任务

如何让每周四18：00 定时执行任务

（任务，当前时间和任务执行时间的时间差，间隔时间，时间单位）

public static void main(String[] args) throws Exception {
    //让每周周四18：00 定时执行任务
    LocalDateTime now=LocalDateTime.now();//线程安全的一个时间类
    //System.out.println(now);

    //获得周四时间
    LocalDateTime time = now.withHour(18).withMinute(0).withSecond(0).withNano(0).with(DayOfWeek.THURSDAY);
    //如果当前时间> 本周周四，必须找到下周周四
    if(now.compareTo(time)>0){
        time=time.plusWeeks(1);//加一周时间
        
    }
    //计算当前时间和要执行任务时间的差值
    long initailDelay = Duration.between(now, time).toMillis();
    

    long period=1000*60*60*24*7;//一周的时间间隔

    ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
    pool.scheduleAtFixedRate(()->{
        System.out.println("running");
    },initailDelay,period,TimeUnit.MICROSECONDS);


}
        time=time.plusWeeks(1);//加一周时间
        
    }
    //计算当前时间和要执行任务时间的差值
    long initailDelay = Duration.between(now, time).toMillis();
    

    long period=1000*60*60*24*7;//一周的时间间隔

    ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
    pool.scheduleAtFixedRate(()->{
        System.out.println("running");
    },initailDelay,period,TimeUnit.MICROSECONDS);


}
你好y
关注
专栏目录
小议线程池--ThreadPoolExecutor和Executors
weixin_43259821的博客
04-25 721
线程池 线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。 合理使用线程池有以下三个好处： 降低资源消耗。通过重复利用已创建好的线程减少线程的创建和销毁造成的消耗 提高响应速度。当任务到达时，不需要等待线程创建就可以立即执行 提高线程的可管理性。线程是珍稀资源，如果无限制地...
Executor与ThreadPoolExecutor
Dream It Possible
11-29 4130
创建线程池 创建无界线程池 ExecutorService executor = Executors.newCachedThreadPool(); 创建固定数量的线程池 ExecutorService executorService = Executors.newFixedThreadPool(3); 创建单一线程的线程池 ExecutorService executorService = Exec
Java多线程:线程池ThreadPoolExecutor和Executors详解(六)
weixin_46204877的博客
05-16 2053
线程池的创建有两种：ThreadPoolExecutor 和 Executors。 线程池不是一个提高系统的并发能力的策略，是一个更好的管理线程的方案。 另外，线程池也提供了许多可调参数和可扩展性接口，以满足不同情境的需要，可以使用更方便的Executors的工厂方法，比如newCachedThreadPool (缓冲线程池，线程池线程个数最多可达Integer.MAX_ VALUE,线程自动回收)、newFixedThreadPool (固定大小的线程池)、newSingleThreadExecutor
源码分析：线程池ThreadPoolExecutor与Executors
CrankZ的博客
05-29 582
先介绍单线程怎么实现，然后有什么问题介绍简单线程池实现，然后说不推荐使用这种方式引出Executors，有五种方式，介绍常用四种方式
Executors和ThreadPoolExecutor详解
川子的博客
05-08 4463
概述 在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool().
Executors与ThreadPoolExecutor
狼行千里吃肉
07-01 222
起因 在查看《Java开发手册（泰山版）》发现这么一段话： 【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors返回的线程池对象的弊端如下： 1）FixedThreadPool和SingleThreadPool： 允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。 2 CachedThreadPool： 允
线程池实例：使用Executors和ThreadPoolExecutor
08-12
NULL 博文链接：https://bijian1013.iteye.com/blog/2284676
threadpoolexecutor和executors
06-06
Executors是Java中的一个工具类，提供了一些静态方法，用于创建线程池。它提供了一些预定义的线程池，如newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor等。这些线程池都是基于...
Android开发之线程池管理ThreadPoolExecutor和Executors.newSingleThreadExecutor()
xiayiye5的博客
09-02 2048
在Android开发中网络请求数据在Android4.0以后禁止在主线程请求，那么我们只有新开启线程请求数据了 一般都喜欢简单点这样写： new Thread(new Runnable() { @Override public void run() { } }).start(); ...
threadpoolexecutor和Executors有什么区别？
03-30
- `Executors` 是一个工厂类，可以创建不同类型的线程池，如 `newFixedThreadPool()`、`newCachedThreadPool()` 等。这些线程池都是使用 `ThreadPoolExecutor` 实现的。 - `ThreadPoolExecutor` 是一个线程池类，...
【Java多线程】线程池 ThreadPoolExecutor类和Executors工厂类以及线程池的最优大小
最新发布
m0_65277261的博客
04-12 1677
主要核心原理 创建一个线程池子，池子中是空的 提交任务时，线程池子会创建新的线程对象，任务执行完毕，线程归还给池子下回再次提交任务时，不需要创建新的线程，直接复用已有的线程即可 但是如果提交任务时，池子中没有空闲线程，也无法创建新的线程，任务就会排队等待
Executor & ThreadPoolExecutor 线程池详解
leimeng123的博客
10-27 4224
在 Java 中，如果每个请求到达就创建一个新线程，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。如果在一个 Jvm 里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。 为了解决这个问题,就有了线程池的概念，线程池的核心逻辑是提前创建好若干个线程放在一个容器中。如果有任务需要处理，则将任务直接分配给线程池中的线程来执行就行，任务处理完以后这个线程不会被销毁，而是等待后续分配任务。同时通过线程池来重复管理线程还可以避免创
线程学习三：线程池ThreadPoolExecutor 与 Executors
人有匪气，代码才能飞起
10-18 993
/**      * Creates a new {@code ThreadPoolExecutor} with the given initial      * parameters.      *      * @param corePoolSize the number of threads to keep in the pool, even      *        if they ar
使用Executors类创建线程池的弊端以及与使用ThreadPoolExecutor类的区别
SmallCarrot的博客
12-15 4257
介绍： 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。 为什么要使用线程池？ 这里借用《Java并发编程的艺术》提到的来说一下使用线程池的好处： 降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。 当任务到达时，任务可以不需要的等到线程创建就能立即执行。 提高线程的可管理性。 线程是稀缺资源，如...
三种Executor、ThreadPoolExecutor、ThreadPoolTaskExecutor线程池
qq_40774600的博客
08-18 574
Java 线程池
为什么不用Executor而是用ThreadPoolExecutor创建线程池
Logan_addoil的博客
07-23 1171
ThreadPoolExecutor threadPool= new ThreadPoolExecutor(5, //核心线程数 10, //最大池的大小 30L,//空闲线程保持时间30 TimeUnit.SECONDS,//时间单位秒 new ArrayBlockingQu...
线程池：ThreadPoolExecutor，ExecutorService，Executors讲解
你怎么还在用 ThinkPad 啊？
07-09 552
线程池 【理解】线程池基本概念 【理解】线程池工作原理 【掌握】自定义线程池 【应用】java内置线程池 【应用】使用java内置线程池完成综合案例 线程池基础 概念介绍 1.什么是线程池 线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。这里的线程就是我们前面学过的线程，这里的任务就是我们学过的实现Runnable或Callable接口的实例对象； 2.为什么使用线程池 使用线程池最大的原因就是可以根据系统的要求和硬件环境灵活的控制
Java 多线程编程之九：使用 Executors 和 ThreadPoolExecutor 实现的 Java 线程池的例子
热门推荐
Defonds 的专栏
08-02 2万+
线程池用来管理工作线程的数量，它持有一个等待被执行的线程的队列。         java.util.concurrent.Executors 提供了 java.util.concurrent.Executor 接口实现来创建 Java 里的线程池。我们写一个简单的程序来解释一下它的工作机制。         首先我们需要有一个 Runnable 类。         WorkerThrea
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值