创建线程的四大方法及线程池的七大参数

为什么要使用线程池?

线程池做的工作主要是控制运行的线程的数量,处理过程中将任务放入队列,然后再线程创建后启动这些任务如果线程的数量超过最大数量,超过数量的线程将排队等候,等其他线程执行完毕,再从队列中取出任务来执行

特点:线程复用,控制最大并发数,管理线程

一、降低资源消耗,通过重复利用已创建的线程降低线程创建和销毁造成的消耗

二、提高响应速度,当任务到达时,任务可以不需要的等到线程创建就能够立刻执行

三、提高线程的可管理性,线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,

还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。

创建线程的前两种方法:继承Thread类,实现Runnable接口
创建线程的第三种方法:使用Callable创建线程

public class Test {
    public static void main(String[] args) throws Exception{
        FutureTask<Integer> futureTask = new FutureTask<>(new Thre());
        Thread thread = new Thread(futureTask,"AAA");
        thread.start();
        while (!futureTask.isDone()){

        }

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

}

class Thre implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("哈哈哈");
        return 1024;
    }
}

创建线程的第四种方法(企业常用):使用线程池创建线程

 public static void main(String[] args){
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        //ExecutorService executorService = Executors.newSingleThreadExecutor();
        //ExecutorService executorService1 = Executors.newCachedThreadPool();
        //模拟10个用户办理业务,
        try {
            for (int i = 0; i < 20; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

    }

下面分析一下  

(1)Executors.newFixedThreaPool(5);

源码:

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

 

(2)Executors.newSingleThreadExecutor()

源码:

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

 

(3)Executors.newCachedThreadPool();

源码:

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

上述线程池创建时底层都是五个参数,接着往下看ThreafPoolExecutor源码:

  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

我们发现,它调用了一个this方法,即它的构造函数,是传的7个参数,点进this方法,源码:

public ThreadPoolExecutor(int corePoolSize,                      //1
                              int maximumPoolSize,               //2
                              long keepAliveTime,                //3
                              TimeUnit unit,                     //4
                              BlockingQueue<Runnable> workQueue, //5
                              ThreadFactory threadFactory,       //6
                              RejectedExecutionHandler handler) { //7
        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;
    }

我们可以清楚的看到,传的是7个参数。下面详细讲解这七大参数:

1.corePoolSize:线程池中的常驻核心线程数

在创建了线程池后,当有请求任务进来之后,就会安排池中的线程去执行请求任务,近似理解为今日当值线程

当线程池中的线程数目达到corePoolSize后,就会把到达的任务放入缓存队列中。

2.maximumPoolSize:线程池能够容纳同时执行的最大线程数,此值必须大于等于1

3.keepAliveTime:多余的空闲线程的存活时间。

当前线程池数量超过corePoolSize时,当空闲时间达到keepAliveTime值时,

多余空闲线程会被销毁直到只剩下corePoolSize个线程为止

默认情况下,只有当线程池中的线程数大于corePoolSize时,keepAliveTime才会起作用,直到线程池找那个的线程数不大于corePoolSize。

4.unit:keepAliveTime的单位

5.workQueue:任务队列,被提交但尚未被执行的任务

6.threadFactory:表示生成线程池中工作线程的线程工厂,用于创建线程一般默认即可

7.handler:拒绝策略,表示当队列满了并且工作线程大于等于线程池最大线程数(maximumPoolSize)时如何处理

 

以上可对比银行网点的办理模式,在这就不详细说了哦,想通了也就完全理解了!!!

 

<think>嗯,用户之前让我介绍了JUC并发工具包,现在又问线程池,显然想更深入了解线程池的部分。首先,我需要回顾之前提到的线程池内容,确保这次回答更详细全面。 用户可能对线程池的基本概念有一定了解,但需要深入原理、参数配置、使用场景以及注意事项。他们可能在实际开发中遇到了性能问题,或者想优化现有的线程池配置。 我需要分结构讲解,比如核心参数、工作流程、常见类型、配置建议和注意事项。要避免使用过多专业术语,用更易懂的例子和场景说明。例如,解释corePoolSize和maxPoolSize时,可以用银行柜台的例子,让读者更容易理解。 另外,用户可能对如何选择线程池类型和配置参数有疑问,比如为什么推荐自定义ThreadPoolExecutor而不是Executors的工厂方法。需要强调资源耗尽的风险,比如OOM,并举出newFixedThreadPool和newCachedThreadPool的问题。 还要提到线程池的工作流程,任务队列的不同类型及其影响,比如LinkedBlockingQueue和SynchronousQueue的区别。可能用户在处理高并发任务时,对任务排队和拒绝策略不太清楚,需要详细说明四种拒绝策略及其适用场景。 在注意事项部分,需要提醒线程池的资源隔离、异常处理以及监控的重要性。特别是异常处理,如果不当可能导致任务静默失败,影响排查。可以给出使用UncaughtExceptionHandler或者Future.get()捕获异常的方法。 最后,总结部分要简明扼要,强调线程池的优势和正确使用的重要性,帮助用户形成系统化的理解。确保回答结构清晰,层次分明,让用户能逐步掌握线程池的核心知识点。</think>### 线程池深度解析:Java并发编程的发动机 线程池是 JUC 中资源管理的核心工具,通过复用线程降低创建/销毁开销,提升系统吞吐量。以下从底层原理到实践场景全面剖析: --- #### 一、线程池核心参数(以 `ThreadPoolExecutor` 为例) ```java new ThreadPoolExecutor( int corePoolSize, // 核心线程数(常驻线程) int maximumPoolSize, // 最大线程数(应急线程) long keepAliveTime, // 非核心线程空闲存活时间 TimeUnit unit, // 时间单位 BlockingQueue<Runnable> workQueue, // 任务队列 ThreadFactory threadFactory, // 线程创建工厂 RejectedExecutionHandler handler // 拒绝策略 ) ``` **参数比喻**: - 核心线程 = 银行固定柜台 - 最大线程 = 临时加开的流动柜台 - 任务队列 = 客户等候区 - 拒绝策略 = 客满时的处理方式 --- #### 二、线程池工作流程(关键执行逻辑) 1. 提交任务时优先使用核心线程 2. 核心线程满 → 任务进入队列 3. 队列满 → 创建非核心线程(不超过 maximumPoolSize) 4. 线程和队列均满 → 触发拒绝策略 **流程图**: ``` 新任务提交 → 核心线程是否满? ├─ 否 → 创建核心线程执行 └─ 是 → 队列是否满? ├─ 否 → 加入队列等待 └─ 是 → 能否创建线程? ├─ 能 → 创建临时线程执行 └─ 不能 → 执行拒绝策略 ``` --- #### 三、四大拒绝策略对比 | 策略类 | 行为 | 适用场景 | |---------------------------------|--------------------------------------|-----------------------| | `AbortPolicy`(默认) | 抛出 `RejectedExecutionException` | 严格要求任务完整性 | | `CallerRunsPolicy` | 由提交任务的线程直接执行 | 流量削峰,降低提交速度 | | `DiscardPolicy` | 静默丢弃新任务 | 允许丢任务(如日志监控)| | `DiscardOldestPolicy` | 丢弃队列最旧任务,重试提交新任务 | 优先处理最新任务 | --- #### 四、常见线程池类型(通过 `Executors` 创建) 1. **固定线程池** ```java ExecutorService fixedPool = Executors.newFixedThreadPool(5); ``` - 特点:corePoolSize = maximumPoolSize,队列无界 - 风险:任务堆积可能导致 OOM 2. **缓存线程池** ```java ExecutorService cachedPool = Executors.newCachedThreadPool(); ``` - 特点:corePoolSize=0,maximumPoolSize=Integer.MAX_VALUE,队列为 `SynchronousQueue` - 风险:线程数量失控 3. **单线程池** ```java ExecutorService singleThreadPool = Executors.newSingleThreadExecutor(); ``` - 特点:保证任务顺序执行,队列无界 - 风险:同固定线程池 4. **定时线程池** ```java ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3); scheduledPool.scheduleAtFixedRate(task, initialDelay, period, unit); ``` - 支持定时/周期性任务 --- #### 五、线程池配置黄金法则 1. **CPU 密集型任务** ```math corePoolSize = CPU核心数 + 1 ``` (如 8 核 CPU → 9 线程) 2. **IO 密集型任务** ```math corePoolSize = CPU核心数 × 2 ``` (如 8 核 CPU → 16 线程) 3. **混合型任务** - 拆分为 CPU 密集和 IO 密集两部分 - 分别使用不同线程池 --- #### 六、生产环境最佳实践 1. **禁止使用 `Executors` 创建线程池** - 推荐手动配置 `ThreadPoolExecutor` 参数 ```java // 标准安全配置示例 new ThreadPoolExecutor( Runtime.getRuntime().availableProcessors(), // 核心线程数 Runtime.getRuntime().availableProcessors() * 2, // 最大线程数 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1000), // 有界队列 new CustomThreadFactory(), // 自定义线程命名 new ThreadPoolExecutor.CallerRunsPolicy() // 降级策略 ); ``` 2. **监控关键指标** ```java ThreadPoolExecutor pool = (ThreadPoolExecutor) executor; System.out.println("活跃线程数:" + pool.getActiveCount()); System.out.println("已完成任务数:" + pool.getCompletedTaskCount()); System.out.println("队列大小:" + pool.getQueue().size()); ``` 3. **优雅关闭** ```java executor.shutdown(); // 停止接收新任务 if (!executor.awaitTermination(60, TimeUnit.SECONDS)) { executor.shutdownNow(); // 强制终止 } ``` --- #### 七、常见问题与解决方案 1. **线程池打满导致服务不可用** - 增加队列容量 - 优化任务处理速度 - 使用熔断机制 2. **线程上下文切换开销大** - 降低线程数量 - 使用协程(需第三方库,如 Quasar) 3. **任务执行异常丢失** - 在任务内加 try-catch - 使用 `Future` 获取异常 ```java Future<?> future = executor.submit(task); try { future.get(); } catch (ExecutionException e) { Throwable cause = e.getCause(); // 处理异常 } ``` --- ### 总结:线程池的三层认知 1. **基础层**:理解核心参数与工作流程 2. **实践层**:根据业务特点选择配置策略 3. **高级层**:监控调优与异常处理体系 **特别提示**:在高并发场景下,建议为不同业务类型使用独立线程池,避免相互影响(如订单处理与日志记录分开)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值