java 线程池的使用及原理（三）：为什么要手动创建线程池

最新推荐文章于 2023-08-19 18:12:17 发布
最新推荐文章于 2023-08-19 18:12:17 发布
阅读量381 收藏 1
点赞数
分类专栏： java 文章标签： 队列 java 多线程 thread 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44245828/article/details/109502517
版权

回顾 java.util.concurrent.Executors 提供的几种线程池，查看源码发现，除了jdk1.8 新增的newWorkStealingPool，其余的都是使用 ThreadPoolExecutor。所以，我们先来看看 ThreadPoolExecutor的神秘力量

ThreadPoolExecutor

  • 了解一个类，先看其构造函数，ThreadPoolExecutor 有以下四个构造函数
/* 构造函数1： 5个参数，调用 7 个参数的构造函数  */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}
/* 构造函数2： 6个参数，调用 7 个参数的构造函数，比构造函数1多了ThreadFactory threadFactory  */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}
/* 构造函数3：6个参数，调用 7 个参数的构造函数，比构造函数1 多了RejectedExecutionHandler handler  */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}
/* 构造函数4： 7个参数，真正干活的构造  */
/* 各个参数的作用
* param1：int corePoolSize ==> 线程池中核心的线程数，即一直工作的个数
* param2：int maximumPoolSize ==> 线程池中最大的线程数，即最忙碌时能开启的线程个数
* param3：long keepAliveTime ==> 空闲线程的存活时间，即不用的线程多久关闭
* param4：TimeUnit unit  ==> 与 param3 配合使用，制定时间单位
* param5：BlockingQueue<Runnable> workQueue ==> 存储任务的阻塞队列，当任务数 > 核心线程corePoolSize 时存储，注意，这里不会先开启线程，任务队列满了才会开启线程，后面证明  
* param6：ThreadFactory threadFactory ==> 线程工厂，负责创建线程工作
* param7：RejectedExecutionHandler handler  ==> 拒绝执行策略，即线程池满了，新任该怎么处理，defaultHandler = new AbortPolicy(); 	
*/
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

证明 param5 所说，超过核心线程数，先放进任务队列，任务队列满了，直接开启线程执行新添加的任务

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class BlockingTest {
    public static void main(String[] args) {
        /* 核心线程：2  最大线程：4  等待队列：2 */
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(2));
        for(int i = 1; i <= 4; i++) {
            int finalI = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(3000);
                    System.out.println("我是线程： " + Thread.currentThread().getName() + "\t 我是先添加的任务" + finalI);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        for(int i = 1; i <= 2; i++) {
            int finalI = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(3000);
                    System.out.println("我是线程： " + Thread.currentThread().getName() + "\t 我是后添加的任务 -->" + finalI);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        threadPool.shutdown();
    }
}
  • 可以看到，后添加的任务开启线程执行，先于 任务3、4。
    在这里插入图片描述

ThreadPoolExecutor 四种拒绝策略

  • AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。
  • DiscardPolicy：丢弃任务，但是不抛出异常。
  • DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务
  • CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务

1. AbortPolicy（默认）

  • AbortPolicy 类源码，可以看到，拒绝策略是 throw RejectedExecutionException()
public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}
  • 测试代码
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class AbortPolicyTest {
    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 5,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(2));

        for(int i = 1; i <= 10; i++) {
            threadPool.execute(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是线程： " + Thread.currentThread().getName());
            });
        }

        Thread.sleep(1000);
        System.out.println("====================== 我是华丽的分割线 ====================");
        for(int i = 1; i <= 5; i++) {
            threadPool.execute(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是线程： " +  Thread.currentThread().getName());
            });
        }

    }
}
  • 抛出 RejectedExecutionException 错误，线程不停止，但不也继续往下执行？
    • 因为从报错信息也可以看出，错误是main线程抛出的， 又 ThreadPoolExecutor 的 allowCoreThreadTimeOut 默认为false，即核心线程一直保持运行，所以线程一直阻塞。在这里插入图片描述

2. DiscardPolicy

  • DiscardPolicy 类源码，rejectedExecution 为空，不做任何工作
public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}
  • 测试代码
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;
import java.util.concurrent.TimeUnit;

public class DiscardPolicyTest {
    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 5,
                0L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(2),
                new DiscardPolicy());

        for(int i = 1; i <= 10; i++) {
            threadPool.execute(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是线程： " + Thread.currentThread().getName());
            });
        }
        // 确保之前的线程不受影响
        Thread.sleep(3000);
        System.out.println("====================== 我是华丽的分割线 ======================");
        for(int i = 1; i <= 10; i++) {
            int finalI = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是 rejectedExecution后执行的线程： " +  Thread.currentThread().getName() + "\t 我是" + finalI);
            });
        }
        threadPool.shutdown();
    }
}

在这里插入图片描述

3. DiscardOldestPolicy

  • DiscardOldestPolicy 类源码，很明显可以看到，poll() 一个，在执行 execute()
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}
  • 测试代码
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
import java.util.concurrent.TimeUnit;

public class DiscardOldestPolicyTest {
    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 5,
                0L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(2),
                new DiscardOldestPolicy());

        for(int i = 1; i <= 20; i++) {
            int finalI = i;
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            threadPool.execute(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是线程： " + Thread.currentThread().getName() + "\t 我是" + finalI);
            });
        }

        Thread.sleep(10000);

        System.out.println("====================== 我是华丽的分割线 ====================");
        for(int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int finalI = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是线程： " +  Thread.currentThread().getName() + "\t 我是" +  finalI);
            });
        }
        threadPool.shutdown();
    }
}
  • 可以看到，i = 19、20 输出了， 可以证明，最后的任务会挤兑前面的任务
    在这里插入图片描述

4. CallerRunsPolicy

  • CallerRunsPolicy 类源码，如果有阻塞，调用者直接执行任务
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}
  • 测试代码
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
import java.util.concurrent.TimeUnit;

public class CallerRunsPolicyTest {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 5,
                0L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(2),
                new CallerRunsPolicy());

        for(int i = 1; i <= 10; i++) {
            int finalI = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是线程： " + Thread.currentThread().getName() + "\t 我是" + finalI);
            });
        }

        Thread.sleep(3000);

        System.out.println("====================== 我是华丽的分割线 ====================");
        for(int i = 1; i <= 10; i++) {
            int finalI = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是线程： " +  Thread.currentThread().getName() + "\t 我是" +  finalI);
            });
        }
        threadPool.shutdown();
    }
}

在这里插入图片描述

回看 java 提供的线程池

newSingleThreadExecutor 、newFixedThreadPool

  • 两者会提供一个无界的等待队列，当等待队列过多时，会报 OOM 异常
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
  • 代码示例
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class newSingleThreadExecutorTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        while(true) {
            executorService.execute(() -> {
                byte[] bytes = new byte[1024 * 1024 * 30];
                System.out.println("===============" + Thread.currentThread().getName());
            });
        }
        executorService.shutdown();
    }
}
  • 为了凸显内存异常，我设置了较小的堆内存参数 -Xms60m -Xmx60m
    在这里插入图片描述

newCachedThreadPool、newScheduledThreadPool

  • 两者会无限创建线程，报 OOM 异常
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}
  • 为了凸显内存异常，我设置了较小的堆内存参数 -Xms60m -Xmx60m
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewCachedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        while(true) {
            executorService.execute(() -> {
                byte[] bytes = new byte[1024 * 1024];
                try {
                    Thread.sleep(10000);
                    System.out.println("===============" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
    }
}

在这里插入图片描述

  • 除此之外，还可自定义等待队列，线程工厂，线程存活之间等。
cerish404
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
给Java开发经验三年左右的小伙伴一些面试建议
m0_67645544的博客
08-30 868
都说现在Java面试卷，前段时间项目招人的时候，我刚好就作为面试官面试了一些工作经验在3年左右的候选人 在整个面试的过程中，我就发现了一些关于面试的通病
Java线程池创建线程及原理探究
猿码天地
03-20 290
Hi，大家好，我是猿人！今天给大家讲讲“Java线程池创建线程及原理探究”，这篇文章是经过自己学习探究，然后参考了一些文献，整理出来的，后续还会写一些关于多线程、并发的文章。其实，通过写作...
为什么一定要用ThreadPoolExecutor创建线程池？
初心不改
08-19 154
线程池的创建方式总共分为两大类：手动使用 ThreadPoolExecutor 创建线程池和自动使用 Executors 执行器创建线程池的方式。其中使用 Executors 自动创建线程的方式，因为线程个数或者任务个数不可控，可能会导致内存溢出的风险，所以在创建线程池时，建议使用 ThreadPoolExecutor 的方式来创建。
手把手教你手动创建线程池
IamHYN的博客
02-28 801
一、为什么要手动创建线程池？ 我们之所以要手动创建线程池，是因为 JDK 自带的工具类所创建的线程池存在一定的弊端，那究竟存在怎么样的弊端呢？首先来回顾一下 JDK 中线程池框架的继承关系： JDK 线程池框架继承关系图 我们最常用的线程池实现类是ThreadPoolExecutor(红框里的那个)，首先我们来看一下它最通用的构造方法： /** * 各参数含义 * corePoolSiz...
Java 从源码的角度去分析：为什么建议手动创建线程池
这就是快乐嘛
12-31 341
提供的有四种线程池：Executors.newFixedThreadPool()、Executors.newSingleThreadExecutor()、Executors.newCachedThreadPool()、Executors.newScheduledThreadPool() 两两为例，从源码的角度去分析这些线程池有什么问题： 第一组Executors.newFixedThreadPool()和Executors.newSingleThreadExecutor() Executors.newFix
手动创建线程池
snow_5的博客
11-24 376
线程池的优势： 线程池做的工作只要控制运行的线程数量，处理过程中将任务放入队列。然后在线程创建后启动这些任务， 如果创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，在从 队列中取出任务来执行。 他的主要特点为：线程服用，控制最大并发数；管理线程。 通常在工作中，我们都是根据实际情况手动创建线程的。说道手动创建线程池时，我们需要用到一个类ThreadPoo...
java线程(四) 线程池原理
asd804171023的博客
10-27 255
线程池 作用：限制线程数，管理线程、避免频繁创建和销毁线程造成性能损耗 ThreadPoolExecutor 作用 封装线程池的一系列逻辑，通过该类可创建线程池。 构造参数 corePoolSize 核心线程数，有任务时才会创建线程，一般情况核心线程不会过期，一直占用，除非调allowCoreThreadTimeOut方法设置允许过期，核心线程才会因为空闲超时而过期 keepAliveTim...
java线程池使用后到底要关闭吗
08-26
java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...
Java线程池示例代码.zip
最新发布
10-26
为什么要用线程池: 减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的内存，而把服务器累趴下(每个线程...
详细分析JAVA 线程池
08-19
2. 为什么需要线程池？ 使用线程池可以提高程序的性能和效率，因为创建一个新线程的成本是比较高的，涉及与操作系统交互。使用线程池可以重用线程，减少创建新线程的开销。 3. Java 5以前的线程池实现 在Java 5以前...
深入理解Java 线程池
08-18
深入理解Java线程池 Java 线程池是 Java 编程中一个非常重要的概念，它可以帮助开发者更好地管理和控制线程的执行，提高系统的性能和效率。在 Java 中，线程池是通过 Executor 框架来实现的，Executor 框架提供了...
java通过Callable和Future来接收线程池的执行结果
08-25
Java通过Callable和Future来接收线程池的执行结果 Java中的线程池执行结果获取一直是一个棘手的问题，对于直接继承Thread的方式或实现Runnable接口的方式，都无法获取到线程执行的返回结果。如果线程在执行过程中...
为何阿里代码规约要求手动创建线程池，我的踩坑和升级
高山仰止，景行行止
10-29 2034
前言 很久没有写点东西了，主要是工作不忙，所忙的工作也都是比较简单的，并未遇到我没有接触过的技术，之前一直有一个需求就是对字段加密，而需要加密的字段有311万多，最初都是用单线程去写的，一次查询2000条，然后加密后一条一条的更新，结果一算，311万得花费5.7个小时，太慢了，于是就看了同事之前写的多线程，拷贝过来发现我的阿里编码规约提示：手动创建线程池,效果会更好哦 解决过程 参考博客 我之前通篇看过阿里编码规约，这块说到了我才有印象。晚上查了一下，参考了这几篇博客 1、阿里不推荐使用Executors创
面试题：为什么要自建线程池
qq_29860591的博客
02-03 600
隐藏的问题 FixedThreadPool 首先我们来看第一种线程池 FixedThreadPool， 它是线程数量固定的线程池，如源码所示，newFixedThreadPool 内部实际还是调用了 ThreadPoolExecutor 构造函数。 publicstaticExecutorServicenewFixedThreadPool(intnThreads){ ...
Executors Java编程规范插件提示手动创建线程池的解决办法
热门推荐
明明如月的技术博客
05-10 2万+
一、背景 最近了解一下线程池，下载其中的代码并运行。 https://howtodoinjava.com/core-java/multi-threading/when-to-use-countdownlatch-java-concurrency-example-tutorial/ 其中ApplicationStartupUtil这个类 package com.chujianyun;...
阿里代码规约：手动创建线程池,效果会更好哦
鲜衣怒马楼兰月
08-30 2万+
规避资源耗尽的风险，高并发下推荐手动创建线程池
什么时候手动创建线程而不使用线程池
u011389515的博客
06-07 2643
1、需要自定义线程的优先级，线程池中线程总是Normal2、需要一个前台线程，线程池中线程是后台线程     非UI线程最好使用线程池创建为后台线程，常常关闭一个软件之后，仍然占有内存，就是由于创建了多个前台线程，程序关闭的时候，还有其他前台线程没有关闭。3、需要手动终止线程，线程池不具有这种功能。4、线程执行时间长，线程池目的是为了线程重用，省去创建新线程的额外开销，多适用于多而执行时间短的线程...
为什么要手动new方式创建线程池-Executors工具类创建线程池的两个潜在问题
weiguanpan3647的博客
09-04 522
ConcurrentHashMap 源码分析07之函数篇 get、compute方法详解
weixin_44245828的博客
12-07 2559
1. get() public V get(Object key) { Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek; int h = spread(key.hashCode()); // 获得 hash 值 /* tab 不为 null && tab数组长度 > 0 && tab对应桶位不为空 */ if ((tab = table) != null &
Java线程池的创建方式、工作原理及使用场景
04-04
1. 使用ThreadPoolExecutor类手动创建线程池，可以指定线程池的大小、任务队列的容量、线程池的拒绝策略等参数。 2. 使用Executors工厂类提供的静态方法创建线程池，如newFixedThreadPool、newCachedThreadPool、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值