Java-线程池动态修改大小

本文详细介绍了Java线程池的参数及其动态调整,包括核心线程数、最大线程数、存活时间等,并讨论了线程池的常见类型如SingleThreadExecutor、CachePool和FixedThreadPool。深入解析ThreadPoolExecutor源码,分析动态更新线程池参数的工作原理及注意事项,提出了线程池参数优化策略和动态指定队列长度的解决方案。
摘要由CSDN通过智能技术生成

参数说明

corePoolSize:核心线程数大小,不管它们创建以后是不是空闲的。线程池需要保持 corePoolSize 数量的线程,除非设置了 allowCoreThreadTimeOut;

maximumPoolSize:最大线程数,线程池中最多允许创建 maximumPoolSize 个线程;

keepAliveTime:存活时间,如果经过 keepAliveTime 时间后,超过核心线程数的线程还没有接受到新的任务,那就回收;

unit: keepAliveTime 的时间单位;

workQueue:存放待执行任务的队列:当提交的任务数超过核心线程数大小后,再提交的任务就存放在这里。它仅仅用来存放被 execute 方法提交的 Runnable 任务;阻塞队列成员表:

threadFactory:线程工厂,用来创建线程工厂。比如这里面可以自定义线程名称,当进行虚拟机栈分析时,看着名字就知道这个线程是哪里来的,不会懵逼;

handler :拒绝策略:当队列里面放满了任务、最大线程数的线程都在工作时,这时继续提交的任务线程池就处理不了,应该执行怎么样的拒绝策略;

Executors - 线程池的工厂

SingleThreadExecutor

new ThreadPoolExecutor(1, 1,
                        0L, TimeUnit.MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>())

为什么还有一个线程的线程池?

  1. 任务队列
  2. 生命周期管理

CachePool

new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                              60L, TimeUnit.SECONDS,
                              new SynchronousQueue<Runnable>())

来一个任务执行一个任务,没有线程活着就新建一个线程

当任务数量忽高忽低时可以考虑

FixedThreadPool

new ThreadPoolExecutor(nThreads, nThreads,
                              0L, TimeUnit.MILLISECONDS,
                              new LinkedBlockingQueue<Runnable>());

线程数是固定的,线程不会被灭活

当任务量比较稳定,可以考虑

ScheduledThreadPool

public ScheduledThreadPoolExecutor(int corePoolSize) {
   
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

定时任务线程池

ForkJoinPool

WorkStealingPool

new ForkJoinPool
    (Runtime.getRuntime().availableProcessors(),
     ForkJoinPool.defaultForkJoinWorkerThreadFactory,
     null, true);

每个线程有自己的一个任务队列,当自己任务队列完成了,可以从其他线程的队列拿一个任务出来执行

并发 vs并行

并发是指任务提交,并行指任务执行

并发是并行的子集

面试题:假如提供一个闹钟服务,订阅这个服务的人特别多,10亿人,怎么优化?

ThreadPoolExecutor源码解析

1、常用变量的解释

// 1. `ctl`,可以看做一个int类型的数字,高3位表示线程池状态,低29位表示worker数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 2. `COUNT_BITS`,`Integer.SIZE`为32,所以`COUNT_BITS`为29
private static final int COUNT_BITS = Integer.SIZE - 3;
// 3. `CAPACITY`,线程池允许的最大线程数。1左移29位,然后减1,即为 2^29 - 1
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits
// 4. 线程池有5种状态,按大小排序如下:RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

// Packing and unpacking ctl
// 5. `runStateOf()`,获取线程池状态,通过按位与操作,低29位将全部变成0
private static int runStateOf(int c)     {
    return c & ~CAPACITY; }
// 6. `workerCountOf()`,获取线程池worker数量,通过按位与操作,高3位将全部变成0
private static int workerCountOf(int c)  {
    return c & CAPACITY; }
// 7. `ctlOf()`,根据线程池状态和线程池worker数量,生成ctl值
private static int ctlOf(int rs, int wc) {
    return rs | wc; }

/*
 * Bit field accessors that don't require unpacking ctl.
 * These depend on the bit layout and on workerCount being never negative.
 */
// 8. `runStateLessThan()`,线程池状态小于xx
private static boolean runStateLessThan(int c, int s) {
   
    return c < s;
}
// 9. `runStateAtLeast()`,线程池状态大于等于xx
private static boolean runStateAtLeast(int c, int s) {
   
    return c >= s;
}

### 回答1: Java中可以使用Java Executor框架来实现动态线程池Java Executor框架提供了一些线程池的实现,如FixedThreadPool,CachedThreadPool和ScheduledThreadPool等。其中,FixedThreadPool是一种固定大小线程池,CachedThreadPool是一种可缓存的线程池,而ScheduledThreadPool是一种可以调度的线程池。 要实现动态线程池,可以使用ThreadPoolExecutor类。ThreadPoolExecutor类提供了构造函数,可以指定线程池的核心线程数、最大线程数、线程空闲时间、任务队列等参数。还提供了一些方法,可以动态修改这些参数。 以下是一个简单的示例代码: ```java import java.util.concurrent.*; public class DynamicThreadPool { public static void main(String[] args) { // 创建ThreadPoolExecutor对象 ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()); // 提交任务 for (int i = 0; i < 10; i++) { executor.execute(new Task(i)); } // 打印线程池状态 System.out.println("Core Pool Size: " + executor.getCorePoolSize()); System.out.println("Max Pool Size: " + executor.getMaximumPoolSize()); System.out.println("Active Count: " + executor.getActiveCount()); System.out.println("Task Count: " + executor.getTaskCount()); System.out.println("Completed Task Count: " + executor.getCompletedTaskCount()); // 修改线程池参数 executor.setCorePoolSize(4); executor.setMaximumPoolSize(6); // 打印线程池状态 System.out.println("Core Pool Size: " + executor.getCorePoolSize()); System.out.println("Max Pool Size: " + executor.getMaximumPoolSize()); System.out.println("Active Count: " + executor.getActiveCount()); System.out.println("Task Count: " + executor.getTaskCount()); System.out.println("Completed Task Count: " + executor.getCompletedTaskCount()); // 关闭线程池 executor.shutdown(); } static class Task implements Runnable { private int taskId; public Task(int taskId) { this.taskId = taskId; } @Override public void run() { System.out.println("Task " + taskId + " is running."); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Task " + taskId + " is completed."); } } } ``` 在上面的代码中,首先创建了一个ThreadPoolExecutor对象,并提交了10个任务。然后打印了线程池的状态。接着修改线程池的核心线程数和最大线程数,并再次打印了线程池的状态。最后关闭了线程池。 ### 回答2: Java中可以使用java.util.concurrent包中的ThreadPoolExecutor类来实现动态线程池。 首先,我们需要创建一个ThreadPoolExecutor对象。在创建对象时,我们可以指定核心线程数、最大线程数、线程空闲时间、任务队列等参数。核心线程数指的是创建的线程池中一直存在的线程数量,最大线程数则是线程池中最多同时存在的线程数量。当核心线程数已满,并且任务队列也满了的情况下,线程池会创建新的线程。线程空闲时间指的是线程如果在空闲状态下超过一定时间没有任务可执行,那么该线程就会被销毁。 接下来,我们可以使用ThreadPoolExecutor的execute方法来提交任务到线程池中。线程池会根据当前的线程数量和任务队列的状态来决定是直接执行任务还是将任务加入队列中。 此外,ThreadPoolExecutor还提供了一些其他的方法来管理线程池,如shutdown方法用于关闭线程池,通过设置allowCoreThreadTimeOut来控制核心线程是否可以被回收等。 总的来说,动态线程池可以根据需要自动创建和销毁线程,有效地管理线程的数量,避免资源浪费和线程阻塞的问题。在实际应用中,动态线程池可以提升系统的性能和响应速度。 ### 回答3: 动态线程池是指可以根据任务的需求自动调整线程数量的线程池Java中可以通过ThreadPoolExecutor类来实现动态线程池。具体步骤如下: 1. 首先,创建一个ThreadPoolExecutor对象,通过构造方法设置线程池的基本属性,例如核心线程数、最大线程数、线程空闲时间等。 `ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());` 2. 设置线程池的拒绝策略,当任务数量超过线程池最大容量时的处理方式。常见的拒绝策略有抛出异常、丢弃任务、手动执行等。 `executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());` 3. 编写任务Runnable的代码,并通过execute()方法将任务提交给线程池执行。 `executor.execute(new Runnable() { public void run() { // 执行任务的代码 } });` 4. 当任务数量超过核心线程数时,线程池会创建新的线程来处理任务。当任务完成后,线程会被重新添加到线程池中,等待下一次任务的执行。线程空闲时间超过keepAliveTime时,线程会被销毁,直到线程数量等于核心线程数。 5. 可以通过调用executor.shutdown()方法来关闭线程池,停止线程池中正在执行的任务,并释放线程池占用的资源。 上述是实现动态线程池的基本步骤,通过ThreadPoolExecutor类的灵活配置,可以满足不同场景下线程池的需求。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值