精华内容
下载资源
问答
  • 常见线程池
    2021-09-08 13:33:01

    newFixedThreadPool:创建固定大小的线程池,每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小;
    newCachedThreadPool:创建一个可缓存的线程池,此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小;
    newScheduledThreadPool:创建一个大小无限的线程池,此线程池支持定时以及周期性执行任务的需求;
    newSingleThreadExecutor:创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。
     
    线程池能够带来三个好处
    第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
    第二:提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行。
    第三:提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。

    更多相关内容
  • Executors类创建四种常见线程池

    千次阅读 2022-03-20 12:05:23
    文章目录 线程池架构newSingleThreadExecutornewFixedThreadPoolnewCachedThreadPoolnewScheduledThreadPoolExecutors和ThreaPoolExecutor创建线程池的区别两种提交任务的方法ex...

    线程池架构

    在这里插入图片描述

    上图是线程池的架构图。Java里面线程池的顶级接口是Executor,Executor并不是一个线程

    池,而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

    比较重要的几个类:

    类/接口描述
    ExecutorService真正的线程池接口
    ScheduledExecutorService能和Timer/TimerTask类似,解决那些需要任务重复执行的问题
    ThreadPoolExecutorExecutorService的默认实现
    ScheduledThreadPoolExecutor继承ThreadPoolExecutor的ScheduledExecutorService接口实现,周期性任务调度的类实现

    要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很有可能配置的线程池不是较优的,因此在Executors类里面提供了一些静态工厂,生成一些常用的线程池。

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

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

    我们先创建一个统一的线程任务,方便测试四种线程池

    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();
        }
    
    }
    
    

    输出结果

    线程任务开始执行
    pool-1-thread-1 is running...
    pool-1-thread-1 is running...
    pool-1-thread-1 is running...
    pool-1-thread-1 is running...
    pool-1-thread-1 is running...
    
    

    底层实现

    /**
     * 核心线程池大小=1
     * 最大线程池大小为1
     * 线程过期时间为0ms
     * LinkedBlockingQueue作为工作队列
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    
    

    从参数可以看出来,SingleThreadExecutor 相当于特殊的 FixedThreadPool,它的执行流程如下:

    1. 线程池中没有线程时,新建一个线程执行任务
    2. 有一个线程以后,将任务加入阻塞队列,不停的加
    3. 唯一的这一个线程不停地去队列里取任务执行

    SingleThreadExecutor 用于串行执行任务的场景,每个任务必须按顺序执行,不需要并发执行

    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();
        }
    
    }
    
    

    输出结果

    线程任务开始执行
    pool-1-thread-1 is running...
    pool-1-thread-1 is running...
    pool-1-thread-2 is running...
    pool-1-thread-1 is running...
    pool-1-thread-2 is running...
    
    

    底层实现

    /**
     * 核心线程池大小=传入参数
     * 最大线程池大小为传入参数
     * 线程过期时间为0ms
     * LinkedBlockingQueue作为工作队列
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    
    

    可以看到,FixedThreadPool 的核心线程数和最大线程数都是指定值,也就是说当线程池中的线程数超过核心线程数后,任务都会被放到阻塞队列中。

    此外 keepAliveTime 为 0,也就是多余的空余线程会被立即终止(由于这里没有多余线程,这个参数也没什么意义了)。

    而这里选用的阻塞队列是 LinkedBlockingQueue,使用的是默认容量 Integer.MAX_VALUE,相当于没有上限。

    因此这个线程池执行任务的流程如下:

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

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

    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();
        }
    
    }
    
    

    输出结果

    线程任务开始执行
    pool-1-thread-1 is running...
    pool-1-thread-4 is running...
    pool-1-thread-2 is running...
    pool-1-thread-5 is running...
    pool-1-thread-3 is running...
    
    

    底层实现

    /**
     *  核心线程池大小=0
     *  最大线程池大小为Integer.MAX_VALUE
     *  线程过期时间为60s
     *  使用SynchronousQueue作为工作队列
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    
    

    可以看到,CachedThreadPool 没有核心线程,非核心线程数无上限,也就是全部使用外包,但是每个外包空闲的时间只有 60 秒,超过后就会被回收。

    CachedThreadPool 使用的队列是 SynchronousQueue,这个队列的作用就是传递任务,并不会保存。

    因此当提交任务的速度大于处理任务的速度时,每次提交一个任务,就会创建一个线程。极端情况下会创建过多的线程,耗尽 CPU 和内存资源。

    它的执行流程如下:

    1. 没有核心线程,直接向 SynchronousQueue 中提交任务
    2. 如果有空闲线程,就去取出任务执行;如果没有空闲线程,就新建一个
    3. 执行完任务的线程有 60 秒生存时间,如果在这个时间内可以接到新任务,就可以继续活下去,否则就拜拜
    4. 由于空闲 60 秒的线程会被终止,长时间保持空闲的 CachedThreadPool 不会占用任何资源。

    CachedThreadPool 用于并发执行大量短期的小任务,或者是负载较轻的服务器

    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("线程任务开始执行");
        }
    
    }
    
    

    输出结果

    线程任务开始执行
    // 打印【线程任务开始执行】后1秒输出
    pool-1-thread-1 is running...
    pool-1-thread-2 is running...
    pool-1-thread-1 is running...
    pool-1-thread-3 is running...
    pool-1-thread-2 is running...
    // 2秒后输出
    pool-1-thread-1 is running...
    pool-1-thread-3 is running...
    pool-1-thread-2 is running...
    pool-1-thread-1 is running...
    pool-1-thread-3 is running...
    
    

    底层实现

    /**
     * 核心线程池大小=传入参数
     * 最大线程池大小为Integer.MAX_VALUE
     * 线程过期时间为0ms
     * DelayedWorkQueue作为工作队列
     */
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }
    
    

    ScheduledThreadPoolExecutor 的执行流程如下:

    1. 添加一个任务
    2. 线程池中的线程从 DelayQueue 中取任务
    3. 然后执行任务

    具体执行任务的步骤也比较复杂:

    1. 线程从 DelayQueue 中获取 time 大于等于当前时间的 ScheduledFutureTask

    2. 执行完后修改这个 task 的 time 为下次被执行的时间

    3. 然后再把这个 task 放回队列中

    ScheduledThreadPoolExecutor 用于需要多个后台线程执行周期任务,同时需要限制线程数量的场景

    Executors和ThreaPoolExecutor创建线程池的区别

    Executors 各个方法的弊端:

    1. newFixedThreadPool 和 newSingleThreadExecutor:
      主要问题是堆积的请求处理队列可能会耗费非常大的内存,甚至 OOM。
    2. newCachedThreadPool 和 newScheduledThreadPool:
      主要问题是线程数最大数是 Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至 OOM。

    ThreaPoolExecutor

    1. 创建线程池方式只有一种,就是走它的构造函数,参数自己指定

    两种提交任务的方法

    ExecutorService 提供了两种提交任务的方法:

    • execute():提交不需要返回值的任务
    • submit():提交需要返回值的任务

    execute

    void execute(Runnable command);
    
    

    execute() 的参数是一个 Runnable,也没有返回值。因此提交后无法判断该任务是否被线程池执行成功。

    ExecutorService executor = Executors.newCachedThreadPool();
    executor.execute(new Runnable() {
        @Override
        public void run() {
            //do something
        }
    });
    
    

    submit

    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    
    

    submit() 有三种重载,参数可以是 Callable 也可以是 Runnable。

    同时它会返回一个 Funture 对象,通过它我们可以判断任务是否执行成功。

    获得执行结果调用 Future.get() 方法,这个方法会阻塞当前线程直到任务完成。

    提交一个 Callable 任务时,需要使用 FutureTask 包一层:

    FutureTask futureTask = new FutureTask(new Callable<String>() {    //创建 Callable 任务
        @Override
        public String call() throws Exception {
            String result = "";
            //do something
            return result;
        }
    });
    Future<?> submit = executor.submit(futureTask);    //提交到线程池
    try {
        Object result = submit.get();    //获取结果
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    
    
    展开全文
  • java中的5种常见线程池

    千次阅读 2021-03-09 16:37:03
    一、线程池简介周所周知,Java创建一个新线程的成本是比较高的。因此在面临大量的多线程任务时,采用线程池几乎成了惯用的做法,线程池其实也是设计模式中享元模式思想的一种应用。一般线程池刚启动时会新建大量的...

    一、线程池简介

    周所周知,Java创建一个新线程的成本是比较高的。因此在面临大量的多线程任务时,采用线程池几乎成了惯用的做法,线程池其实也是设计模式中享元模式思想的一种应用。

    一般线程池刚启动时会新建大量的(跟传入参数有关)空闲线程,程序将一个Runnable或者Callable对象传给线程池时,线程池会调用空闲线程执行他们的run()方法或者call()方法。执行完成后并不回收该线程,而是再次返回线程池中称谓空闲线程,等待下一次任务。

    二、Java线程池

    Java 5以前,开发者需要手动实现线程池,从Java 5 开始,Java支持了内建线程池,提供了一个Executors类来新建线程池,它位于java.util.concurrent包下,基本上所有跟并发编程相关的都在该包下面。

    Java 常用的线程池有7种,他们分别是:

    (1)newCachedThreadPool :创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。

    (2)newFixedThreadPool:创建一个固定数目的、可重用的线程池。

    (3)newScheduledThreadPool:创建一个定长线程池,支持定时及周期性任务执行。

    (4)newSingleThreadExecutor:创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

    (5)newSingleThreadScheduledExcutor:创建一个单例线程池,定期或延时执行任务。

    (6)newWorkStealingPool:创建持有足够线程的线程池来支持给定的并行级别,并通过使用多个队列,减少竞争,它需要穿一个并行级别的参数,如果不传,则被设定为默认的CPU数量。

    (7) ForkJoinPool:支持大任务分解成小任务的线程池,这是Java8新增线程池,通常配合ForkJoinTask接口的子类RecursiveAction或RecursiveTask使用。

    三、示例代码(只介绍代表性的几个)

    (1)newCachedThreadPool 会根据任务来临的需要决定是否创建新的线程,也就是如果来了新任务又没有空闲线程,它就会新建一个线程,下面用代码可以理解这个事情。

    package com;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    public class Main {

    public static void main(String[] args) throws Exception {

    ExecutorService m=Executors.newCachedThreadPool();

    for(int i=1;i<=10;i++){

    final int count=i;

    m.submit(new Runnable(){

    @Override

    public void run() {

    System.out.println("线程:"+Thread.currentThread()+"负责了"+count+"次任务");

    }

    });

    //下面这行代码注释的话,线程池会新建10个线程,不注释的话,因为会复用老线程,不会产生10个线程

    //            Thread.sleep(1);

    }

    }

    }

    注释掉Thread.sleep(1)的结果如下——产生了10个线程

    线程:Thread[pool-1-thread-1,5,main]负责了1次任务

    线程:Thread[pool-1-thread-2,5,main]负责了2次任务

    线程:Thread[pool-1-thread-3,5,main]负责了3次任务

    线程:Thread[pool-1-thread-4,5,main]负责了4次任务

    线程:Thread[pool-1-thread-5,5,main]负责了5次任务

    线程:Thread[pool-1-thread-6,5,main]负责了6次任务

    线程:Thread[pool-1-thread-7,5,main]负责了7次任务

    线程:Thread[pool-1-thread-8,5,main]负责了8次任务

    线程:Thread[pool-1-thread-9,5,main]负责了9次任务

    线程:Thread[pool-1-thread-10,5,main]负责了10次任务

    不注释掉Thread.sleep(1)的结果如下——产生了2个线程

    线程:Thread[pool-1-thread-1,5,main]负责了1次任务

    线程:Thread[pool-1-thread-2,5,main]负责了2次任务

    线程:Thread[pool-1-thread-2,5,main]负责了3次任务

    线程:Thread[pool-1-thread-2,5,main]负责了4次任务

    线程:Thread[pool-1-thread-2,5,main]负责了5次任务

    线程:Thread[pool-1-thread-2,5,main]负责了6次任务

    线程:Thread[pool-1-thread-2,5,main]负责了7次任务

    线程:Thread[pool-1-thread-2,5,main]负责了8次任务

    线程:Thread[pool-1-thread-2,5,main]负责了9次任务

    线程:Thread[pool-1-thread-2,5,main]负责了10次任务

    (2)newFixedThreadPool 创建一个固定大小的、可重用是线程池

    package com;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    public class Main {

    public static void main(String[] args) throws Exception {

    ExecutorService m=Executors.newFixedThreadPool(4);

    for(int i=1;i<=10;i++){

    final int count=i;

    m.submit(new Runnable(){

    @Override

    public void run() {

    System.out.println("线程:"+Thread.currentThread()+"负责了"+count+"次任务");

    }

    });

    Thread.sleep(1000);

    }

    }

    }

    结果如下:

    线程:Thread[pool-1-thread-1,5,main]负责了1次任务

    线程:Thread[pool-1-thread-2,5,main]负责了2次任务

    线程:Thread[pool-1-thread-3,5,main]负责了3次任务

    线程:Thread[pool-1-thread-4,5,main]负责了4次任务

    线程:Thread[pool-1-thread-1,5,main]负责了5次任务

    线程:Thread[pool-1-thread-2,5,main]负责了6次任务

    线程:Thread[pool-1-thread-3,5,main]负责了7次任务

    线程:Thread[pool-1-thread-4,5,main]负责了8次任务

    线程:Thread[pool-1-thread-1,5,main]负责了9次任务

    线程:Thread[pool-1-thread-2,5,main]负责了10次任务

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

    package com;

    import java.util.Date;

    import java.util.concurrent.Executors;

    import java.util.concurrent.ScheduledExecutorService;

    import java.util.concurrent.TimeUnit;

    public class Main {

    public static void main(String[] args) throws Exception {

    // 指定大小为4

    ScheduledExecutorService m = Executors.newScheduledThreadPool(4);

    m.scheduleAtFixedRate(new Runnable() {

    @Override

    public void run() {

    Date now = new Date();

    System.out.println("线程" + Thread.currentThread() + "报时:" + now);

    }

    }, 1, 1, TimeUnit.SECONDS); // 延迟1s秒执行,每隔1s执行一次

    }

    }

    结果

    线程Thread[pool-1-thread-1,5,main]报时:Thu Sep 10 14:55:15 CST 2015

    线程Thread[pool-1-thread-1,5,main]报时:Thu Sep 10 14:55:16 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:17 CST 2015

    线程Thread[pool-1-thread-1,5,main]报时:Thu Sep 10 14:55:18 CST 2015

    线程Thread[pool-1-thread-1,5,main]报时:Thu Sep 10 14:55:19 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:20 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:21 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:22 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:23 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:24 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:25 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:26 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:27 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:28 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:29 CST 2015

    线程Thread[pool-1-thread-2,5,main]报时:Thu Sep 10 14:55:30 CST 2015

    (4)newWorkStealingPool创建一个带并行级别的线程池,并行级别决定了同一时刻最多有多少个线程在执行,如不穿如并行级别参数,将默认为当前系统的CPU个数。下面用代码来体现这种并行的限制,从结果中可以看到,同一时刻只有两个线程执行。

    package com;

    import java.util.Date;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    public class Main {

    public static void main(String[] args) throws Exception {

    // 设置并行级别为2,即默认每时每刻只有2个线程同时执行

    ExecutorService m = Executors.newWorkStealingPool(2);

    for (int i = 1; i <= 10; i++) {

    final int count=i;

    m.submit(new Runnable() {

    @Override

    public void run() {

    Date now=new Date();

    System.out.println("线程" + Thread.currentThread() + "完成任务:"

    + count+"   时间为:"+    now.getSeconds());

    try {

    Thread.sleep(1000);//此任务耗时1s

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    });

    }

    while(true){

    //主线程陷入死循环,来观察结果,否则是看不到结果的

    }

    }

    }

    结果:

    线程Thread[ForkJoinPool-1-worker-1,5,main]完成任务:1   时间为:7

    线程Thread[ForkJoinPool-1-worker-0,5,main]完成任务:2   时间为:7

    线程Thread[ForkJoinPool-1-worker-1,5,main]完成任务:3   时间为:8

    线程Thread[ForkJoinPool-1-worker-0,5,main]完成任务:4   时间为:8

    线程Thread[ForkJoinPool-1-worker-1,5,main]完成任务:5   时间为:9

    线程Thread[ForkJoinPool-1-worker-0,5,main]完成任务:6   时间为:9

    线程Thread[ForkJoinPool-1-worker-1,5,main]完成任务:7   时间为:10

    线程Thread[ForkJoinPool-1-worker-0,5,main]完成任务:8   时间为:10

    线程Thread[ForkJoinPool-1-worker-1,5,main]完成任务:9   时间为:11

    线程Thread[ForkJoinPool-1-worker-0,5,main]完成任务:10   时间为:11

    三、总结

    以上几个线程池基本满足了常用的线程池需求,开发者可根据场景灵活选中,其中可以实现大任务分解的ForkJoinPool线程池的介绍因为篇幅较长,专门单独写了一篇博客,地址是: Java 多线程中的任务分解机制-ForkJoinPool详解

    ---------------------

    作者:山中小僧

    来源:CSDN

    原文:https://blog.csdn.net/a369414641/article/details/48342253

    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 四种常见线程池解析

    2021-03-09 11:03:44
    线程池线程池的概念四种常见线程池示例代码:示例代码:示例代码:示例代码: 线程池的概念 线程池就是多个线程的集合。使用线程池可以很好地提高性能,线程池在系统启动时即创建大量空闲的线程,程序将一个任务传给...

    一、线程池简介

    1.1线程池概念

    线程池就是多个线程的集合。使用线程池可以很好地提高性能,线程池在系统启动时即创建大量空闲的线程,程序将一个任务传给线程池,线程池就会启动一条线程来执行这个任务,执行结束以后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个任务。

    1.2线程池优势

    1.降低系统资源消耗。通过重用已存在的线程,降低线程创建和销毁造成的消耗;
    2.提高系统响应速度。当有任务到达时,复用已存在的线程,无需等待新线程的创建便能立即执行;
    3.方便线程并发数的管控。因为线程若是无限制的创建,可能会导致内存占用过多而产生OOM,并且会造成cpu过度切换(cpu切换线程是有时间成本的(需要保持当前执行线程的现场,并恢复要执行线程的现场))。
    4.提供更强大的功能。延时定时线程池。

    1.3线程池主要参数

    1.corePoolSize(线程池基本大小):当向线程池提交一个任务时,若线程池已创建的线程数小于corePoolSize,即便此时存在空闲线程,也会通过创建一个新线程来执行该任务,直到已创建的线程数大于或等于corePoolSize时,(除了利用提交新任务来创建和启动线程(按需构造),也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。)

    2.maximumPoolSize(线程池最大大小):线程池所允许的最大线程个数。当队列满了,且已创建的线程数小于maximumPoolSize,则线程池会创建新的线程来执行任务。另外,对于无界队列,可忽略该参数。

    3.keepAliveTime(线程存活保持时间)当线程池中线程数大于核心线程数时,线程的空闲时间如果超过线程存活时间,那么这个线程就会被销毁,直到线程池中的线程数小于等于核心线程数。

    4.workQueue(任务队列):用于传输和保存等待执行任务的阻塞队列。

    5.threadFactory(线程工厂):用于创建新线程。threadFactory创建的线程也是采用new Thread()方式,threadFactory创建的线程名都具有统一的风格:pool-m-thread-n(m为线程池的编号,n为线程池内的线程编号)。

    6.handler(线程饱和策略):当线程池和队列都满了,再加入线程会执行此策略。

    二、四种常见线程池

    ExecutorService类
    ExecutorService类由Java提供的用于管理线程池,该类的两个作用是控制线程数量和重用线程。

    四种常用线程池实现如下(返回值都是ExecutorService)
    1.Executors.newCacheThreadPool():可缓存线程池,先查看池中有没有以前建立的线程,如果有,就直接使用。如果没有,就建一个新的线程加入池中,缓存型池子通常用于执行一些生存期很短的异步型任务。

    示例代码:

    package com.channelPool.test;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class NewCachedThreadPoolTest {
        public static void main(String[] args) {
            // 创建一个cached线程池
            ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
            for (int i = 0; i < 5; i++) {
                try {
                    // sleep可明显看到没有创建新的线程,使用的线程都是以前线程池中存在的
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                cachedThreadPool.execute(new Runnable() {
                    public void run() {
                        // 打印正在执行的缓存线程信息
                        System.out.println(Thread.currentThread().getName()
                                + "正在被执行");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    

    输出结果:

    pool-1-thread-1正在被执行
    pool-1-thread-1正在被执行
    pool-1-thread-1正在被执行
    pool-1-thread-1正在被执行
    pool-1-thread-1正在被执行

    如果线程池无限大,执行当前任务的上一个任务已经完成则会复用上一个任务,而不是创建一个新的线程。

    2.Executors.newFixedThreadPool(int n):创建一个可重用固定个数的线程池,以共享的无界队列方式来运行这些线程。

    示例代码:

    package com.channelPool.test;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class NewFixedThreadPoolTest {
    
        public static void main(String[] args) {
            // 创建一个可重用固定个数的线程池
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
            for (int i = 0; i < 9; i++) {
                fixedThreadPool.execute(new Runnable() {
                    public void run() {
                        try {
                            // 打印正在执行的缓存线程信息
                            System.out.println(Thread.currentThread().getName()
                                    + "正在被执行");
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    }
    

    输出结果:

    pool-1-thread-1正在被执行
    pool-1-thread-2正在被执行
    pool-1-thread-3正在被执行
    pool-1-thread-4正在被执行
    pool-1-thread-1正在被执行
    pool-1-thread-2正在被执行
    pool-1-thread-3正在被执行
    pool-1-thread-4正在被执行
    pool-1-thread-1正在被执行

    线程池的大小为4,每个任务输出打印后都会sleep2秒所以每过两秒就打印4个结果。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。

    3.Executors.newScheduledThreadPool(int n):创建一个定长线程池,支持定时及周期性任务执行。

    示例代码:

    package com.channelPool.test;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class NewScheduledThreadPoolTest {
    
        public static void main(String[] args) {
                     //创建一个定长线程池,支持定时及周期性任务执行——延迟执行
                     ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
                     //延迟执行
                     //延迟1秒执行
                     scheduledThreadPool.schedule(new Runnable() {
                         public void run() {
                            System.out.println("延迟1秒执行");
                         }
                     }, 1, TimeUnit.SECONDS);
                     
                     //定期执行
                     //延迟1秒后每3秒执行一次
                     scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                         public void run() {
                             System.out.println("延迟1秒后每3秒执行一次");
                         }
                    }, 1, 3, TimeUnit.SECONDS);
                 } 
    }
    

    延时执行输出结果:延迟1秒执行
    定期执行输出结果:延迟1秒后每3秒执行一次

    4.Executors.newSingleThreadExecutor():创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

    示例代码:

    package com.channelPool.test;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class NewSingleThreadExecutorTest {			
    
    	public static void main(String[] args) {		          
    			//创建一个单线程化的线程池		          
    			ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();	
    			for (int i = 0; i < 10; i++) {		         					  				            
    				 final int index = i;		             
    				 singleThreadExecutor.execute(new Runnable() {		                 
    				 	public void run() {		                    
    				 		try {		                         
    				 		//结果依次输出,相当于顺序执行各个任务	
    			System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);	
    					Thread.sleep(5000);					                         					                         		                     
    							} 
    						catch (InterruptedException e) {
    							e.printStackTrace();		                     
    						}		                 
    					}		             
    				});		         
    			}		     
    		}
    	}
    

    输出结果:

    pool-1-thread-1正在被执行,打印的值是: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正在被执行,打印的值是:5
    pool-1-thread-1正在被执行,打印的值是:6
    pool-1-thread-1正在被执行,打印的值是:7
    pool-1-thread-1正在被执行,打印的值是:8
    pool-1-thread-1正在被执行,打印的值是:9

    参考链接:
    [https://www.cnblogs.com/jiawen010/p/11855768.html]

    展开全文
  • Java中的常见线程池

    2021-07-26 21:43:33
    目录Java中的常见线程池类型区别使用 不积跬步,无以至千里;不积小流,无以成江海。要沉下心来,诗和远方的路费真的很贵! Java中的常见线程池 类型 newCacheThreadPool newFixedThreadPool newSingleThreadPool ...
  • 常见线程池的使用

    2021-05-01 19:42:03
    为什么使用线程池 1.如果我们需要很多线程,并且线程执行任务的时间又短的时候。我们需要完成这些过程创建任务,创建线程,线程执行,关闭线程。而这些过程中创建线程和关闭线程会占用大量的时间和资源。 2.所以就有...
  • 线程池 概念 线程池就是首先创建一些线程,他们的集合称为线程池,使用线程池可以很好的提高性能。 5种状态 ThreadPoolExecutor 使用int的高3位来表示线程池状态,低29位表示线程数量 状态名 高3位 说明 ...
  • 一、Executors 提供几种常见线程池,参数如何定义? 1. newFixedThreadPool:创建固定核心数的线程池 public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads,...
  • 线程池 线程池:Executor管理多个异步任务的执行,而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰,不需要进行同步操作。 主要有四种线程池: 1. 缓存池 newCachedThreadPool创建...
  • java线程池总结ThreadPoolExecutor线程池线程池的4个构造方法。`ThreadPoolExecutor`的策略参数实例解释**阻塞队列` BlockingQueue workQueue`**`SynchronousQueue``ArrayBlockingQueue``LinkedBlockingQueue``...
  • 常见线程池的具体用法。
  • Java常见线程池有哪些?

    千次阅读 2021-08-15 21:58:35
    1、什么是线程池 java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池 多线程技术主要解决处理器单元内多个线程执行的问题,它可以显著减少处理器单元的闲置时间...
  • 四种常见线程池

    千次阅读 2021-03-04 16:40:34
    在Java中使用线程池,可以用ThreadPoolExecutor的构造函数直接创建出线程池实例。不过,在Executors类中,为我们提供了常用线程池的创建方法。接下来我们就来了解常用的四种: newFixedThreadPool 首先,看一下这种...
  • 什么是阻塞队列线程池的工作队列线程池执行流程几种常见线程池newFixedThreadPoolnewCachedThreadPoolnewSingleThreadExecutornewScheduledThreadPool底层原理参数简介饱和拒绝策略创建线程池什么是死锁手写一个...
  • java中四种常见线程池

    2019-06-04 15:52:47
    java中四种常见线程池 Java通过Executors类提供四种线程池,我们查看源码可以知道,这四种线程池内部都是基于ThreadPoolExecutor类(Executor的子类)实现的。分别为: newCachedThreadPool 创建一个可缓存...
  • 常见线程池种类

    千次阅读 2019-11-08 09:30:15
    创建固定线程数的线程池,使用的是LinkedBlockingQueue无界队列,线程池中实际线程数永远不会变化 适用于可以预测线程数量的业务中,或者服务器负载较重,对线程数有严格限制的场景 Executors....
  • 一、什么是线程池线程池就是事先创建若干个可执行的线程放入一个池(容器)中,一开始需要的时候直接从池中获取线程,不用自行创建,使用完毕后也不需要销毁线程,而是将其放回线程池中,这样可以大大减少创建和...
  • 本文将讲解线程池参数、参数之间的关系以及线程池以一个怎么样的策略执行新增到线程池的线程,最后会举例常见线程池是怎么样应用这些参数和流程的。文章较长,可以根据目录选择想看的知识,若有错误请指出。 1....
  • 三种线程池所用时间的观测 如下代码所示: public class ThreadPoolDemo { public static void main(String[] args) { ExecutorService executorService = Executors.newCachedThreadPool(); ExecutorService ...
  • 2.8.9 线程池 定义:是一种标准的资源池模式 资源池:在用户出现之前,提前预留活跃资源,从而在用户出现的第一时间,直接满足用户对资源的需求,另外将创建和销毁的操作委托给资源池完成,从而提优用户的感受 一个...
  • 使用线程池可以很好地提高性能,线程池在系统启动时即创建大量空闲的线程,程序将一个任务传给线程池线程池就会启动一条线程来执行这个任务,执行结束以后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,...
  • 常见的4种线程池

    千次阅读 2021-03-04 10:28:31
    * 一个可缓存线程池,如果线程池长度超过需要处理需要,可灵活回收空闲线程,若无可回收,则新建线程 * 适合短时间的任务 * 缺点:要问题是线程数最大数是Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至...
  • 同事今天服务报错如下,看了下线程池的创建方式:方法逻辑是创建临时线程池然后关闭,他在代码中获取的全局线程池,方法结束给关闭了,这个异常相对比较简单,自定义线程池的时候,新建的线程加入不到线程池中,触发...
  • 深入浅出多线程编程实战(七)六种常见线程池讲解 文章目录一、线程池介绍二、java常用线程池关系1.六种常用线程池2.类图及主要方法三.线程池实现类讲解1.FixedThreadPool2.SingleThreadExecutor3.CachedThreadPool...
  • Java 四种常见线程池解析

    千次阅读 2018-10-05 15:56:55
    目录四种常见线程池ThreadPoolExecutorFixedThreadPoolChachedThreadPoolSingleThreadExecutorScheduledThreadPool 四种常见线程池 线程池用于管理线程的创建与销毁,避免无用线程造成资源浪费,当需要创建多个...
  • 线程池各类区别使用场景, 工作久了才知道理论的重要性。
  • 线程池以及四种常见线程池 public ThreadPoolExecutor(int corePoolSize,//核心线程池大小,核心线程将会尽可能地一直活着 int maximumPoolSize,//线程池最大数量包括核心线程数量 long keepAliveTime,//非核心...
  • 四种常用线程池介绍与使用场景 1、FixedThreadPool 2、CachedThreadPool 3、SingleThreadExecutor 4、ScheduledThreadPoolExecutor 一、FixedThreadPool public static ExecutorService newFixedThreadPool...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 96,886
精华内容 38,754
关键字:

常见线程池