java.util.concurrent解析及线程池常用参数

最新推荐文章于 2023-03-07 18:34:04 发布

每天多学一点点.

最新推荐文章于 2023-03-07 18:34:04 发布

阅读量395

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/JAVA_I_want/article/details/103095237

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1 java.util.concurrent

1.1 主要部件

java.util.concurrent中包含了太多的功能，在本文中，我们将主要关注此包中一些最有用的实用程序，如：

• Executor
• ExecutorService
• ScheduledExecutorService
• Future
• CountDownLatch
• CyclicBarrier
• Semaphore
• ThreadFactory
• BlockingQueue
• DelayQueue
• Locks
• Phaser

1.2 Executor

Executor是一个表示执行提供的任务的对象的接口。
如果任务应在新线程或当前线程上运行，则它取决于特定实现（从启动调用的位置）。因此，使用此接口，我们可以将任务执行流与实际任务执行机制分离。
这里要注意的一点是，Executor并不严格要求任务执行是异步的。在最简单的情况下，执行程序可以在调用线程中立即调用提交的任务。
我们需要创建一个调用者来创建执行者实例：

public class Invoker implements Executor {
    @Override
    public void execute(Runnable r) {
        r.run();
    }
}

现在，我们可以使用此调用程序来执行任务：

public void execute() {
    Executor executor = new Invoker();
    executor.execute( () -> {
        // task to be performed
    });
}

这里要注意的是，如果执行程序不能接受执行任务，它将抛出RejectedExecutionException。

1.3 ExecutorService

ExecutorService是异步处理的完整解决方案。它管理内存中队列并根据线程可用性计划提交的任务。
要使用ExecutorService，我们需要创建一个Runnable类。

public class Task implements Runnable {
    @Override
    public void run() {
        // task details
    }
}

现在我们可以创建ExecutorService实例并分配此任务。在创建时，我们需要指定线程池大小。

ExecutorService executor = Executors.newFixedThreadPool(10);

如果我们要创建单线程ExecutorService实例，我们可以使用newSingleThreadExecutor（ThreadFactory threadFactory）来创建实例。
创建执行程序后，我们可以使用它来提交任务。

public void execute() { 
    executor.submit(new Task()); 
}

我们还可以在提交任务时创建Runnable实例。

executor.submit(() -> {
    new Task();
});

它还带有两个开箱即用的执行终止方法。第一个是shutdown（） ; 它等待所有提交的任务完成执行。另一种方法是执行shutdownNow（） which立即终止所有未决/执行的任务。
还有另一种方法awaitTermination（长超时，TimeUnit单元）强制阻塞，直到所有任务在触发关闭事件或执行超时发生后完成执行，或者执行线程本身被中断

try {
    executor.awaitTermination( 20l, TimeUnit.NANOSECONDS );
} catch (InterruptedException e) {
    e.printStackTrace();
}

1.4 ScheduledExecutorService

ScheduledExecutorService是与ExecutorService类似的接口，但它可以定期执行任务。
Executor和ExecutorService的方法是在现场安排的，没有引入任何人工延迟。零或任何负值表示需要立即执行请求。
我们可以使用Runnable和Callable接口来定义任务。

public void execute() {
    ScheduledExecutorService executorService
      = Executors.newSingleThreadScheduledExecutor();
 
    Future<String> future = executorService.schedule(() -> {
        // ...
        return "Hello world";
    }, 1, TimeUnit.SECONDS);
 
    ScheduledFuture<?> scheduledFuture = executorService.schedule(() -> {
        // ...
    }, 1, TimeUnit.SECONDS);
 
    executorService.shutdown();
}

ScheduledExecutorService还可以在一些给定的固定延迟后调度任务：

executorService.scheduleAtFixedRate(() -> {
    // ...
}, 1, 10, TimeUnit.SECONDS);
 
executorService.scheduleWithFixedDelay(() -> {
    // ...
}, 1, 10, TimeUnit.SECONDS);

这里，scheduleAtFixedRate（Runnable命令，long initialDelay，long period，TimeUnit unit）方法创建并执行一个周期性操作，该操作在提供的初始延迟之后首先被调用，随后是给定的时间段，直到服务实例关闭。
所述scheduleWithFixedDelay（可运行命令，长在initialDelay，长的延迟，TIMEUNIT单元）方法与所述执行的一个的终止和的调用之间的给定的延迟创建并执行所提供的初始延迟后首先调用的周期性动作，并重复地下一个。

1.5 Future

Future用于表示异步操作的结果。它带有检查异步操作是否完成，获取计算结果等的方法。
而且，cancel（boolean mayInterruptIfRunning） API取消操作并释放执行线程。如果mayInterruptIfRunning的值为true，则执行任务的线程将立即终止。

public void invoke() {
    ExecutorService executorService = Executors.newFixedThreadPool(10);
 
    Future<String> future = executorService.submit(() -> {
        // ...
        Thread.sleep(10000l);
        return "Hello world";
    });
}

我们可以使用以下代码片段来检查未来结果是否准备就绪，并在计算完成后获取数据：

if (future.isDone() && !future.isCancelled()) {
    try {
        str = future.get();
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

我们还可以为给定的操作指定超时。如果任务花费的时间超过此时间，则抛出TimeoutException：

try {
    future.get(10, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
    e.printStackTrace();
}

1.6 CountDownLatch

CountDownLatch（在JDK 5中引入）是一个实用程序类，它阻止一组线程，直到某些操作完成。
CountDownLatch初始化为计数器（整数型）; 当依赖线程完成执行时，此计数器递减。但是一旦计数器达到零，其他线程就会被释放。
其它解释请参考:CountDownLatch详解

1.7 CyclicBarrier

CyclicBarrier与CountDownLatch几乎相同，只是我们可以重用它。与CountDownLatch不同，它允许多个线程在调用最终任务之前使用await（）方法（称为障碍条件）彼此等待。
我们需要创建一个Runnable任务实例来启动屏障条件：

public class Task implements Runnable {
 
    private CyclicBarrier barrier;
 
    public Task(CyclicBarrier barrier) {
        this.barrier = barrier;
    }
 
    @Override
    public void run() {
        try {
            LOG.info(Thread.currentThread().getName() + 
              " is waiting");
            barrier.await();
            LOG.info(Thread.currentThread().getName() + 
              " is released");
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
 
}

现在我们可以调用一些线程来竞争障碍条件：

public void start() {
 
    CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> {
        // ...
        LOG.info("All previous tasks are completed");
    });
 
    Thread t1 = new Thread(new Task(cyclicBarrier), "T1"); 
    Thread t2 = new Thread(new Task(cyclicBarrier), "T2"); 
    Thread t3 = new Thread(new Task(cyclicBarrier), "T3"); 
 
    if (!cyclicBarrier.isBroken()) { 
        t1.start(); 
        t2.start(); 
        t3.start(); 
    }
}

这里，isBroken（）方法检查在执行期间是否有任何线程被中断。在执行实际过程之前，我们应该始终执行此检查。
其它解释请参考:CyclicBarrier详解

1.8 Semaphore

Semaphore的信号量被用于阻挡到物理或逻辑资源的某些部分螺纹级别的访问。
信号量包含一组许可证; 每当线程试图进入临界区时，如果有可用许可证，它需要检查信号量。如果没有许可证（通过tryAcquire（）），则不允许该线程跳入临界区;
但是，如果许可证可用，则授予访问权限，许可证计数器减少。一旦执行线程释放临界区，则许可计数器再次增加（由release（）方法完成）。
我们可以使用tryAcquire（long timeout，TimeUnit unit）方法指定获取访问权限的超时时间。
我们还可以检查可用许可证的数量或等待获取信号量的线程数。
以下代码片段可用于使用实现信号量：

static Semaphore semaphore = new Semaphore(10);
 
public void execute() throws InterruptedException {
 
    LOG.info("Available permit : " + semaphore.availablePermits());
    LOG.info("Number of threads waiting to acquire: " + 
      semaphore.getQueueLength());
 
    if (semaphore.tryAcquire()) {
        semaphore.acquire();
        // ...
        semaphore.release();
    }
 
}

我们可以使用Semaphore实现类似Mutex的数据结构

1.9 ThreadFactory

顾名思义，ThreadFactory充当线程（不存在）池，它根据需要创建新线程。它消除了大量样板编码的需要，以实现有效的线程创建机制。
我们可以定义一个ThreadFactory：

public class BaeldungThreadFactory implements ThreadFactory {
    private int threadId;
    private String name;
 
    public BaeldungThreadFactory(String name) {
        threadId = 1;
        this.name = name;
    }
 
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, name + "-Thread_" + threadId);
        LOG.info("created new thread with id : " + threadId +
            " and name : " + t.getName());
        threadId++;
        return t;
    }
}

我们可以使用这个newThread（Runnable r）方法在运行时创建一个新线程：

BaeldungThreadFactory factory = new BaeldungThreadFactory( 
    "BaeldungThreadFactory");
for (int i = 0; i < 10; i++) { 
    Thread t = factory.newThread(new Task());
    t.start(); 
}

1.10 BlockingQueue

在异步编程中，最常见的集成模式之一是生产者 - 消费者模式。该的java.util.concurrent包带有一个数据结构所知道的BlockingQueue的 -它可以在这些异步情况下非常有用的。

1.11 DelayQueue

DelayQueue是一个无限大小的元素阻塞队列，只有当元素的到期时间（称为用户定义的延迟）完成时才能被拉出。因此，最顶部的元素（头部）将具有最大量的延迟并且将最后轮询。

1.12 Lock

毫不奇怪，Lock是一个实用程序，用于阻止其他线程访问某段代码，除了当前正在执行它的线程。
Lock和Synchronized块之间的主要区别在于synchronized块完全包含在方法中; 但是，我们可以在单独的方法中使用Lock API的lock（）和unlock（）操作。

1.13 Phaser

Phaser是比CyclicBarrier和CountDownLatch更灵活的解决方案- 用作可重复使用的屏障，动态线程数在继续执行之前需要等待。我们可以协调多个执行阶段，为每个程序阶段重用Phaser实例。

2 线程池中常用参数

2.1 java中的线程池（ThreadPoolExecutor）

说起java中的线程池，就想到java.util.concurrent.ThreadPoolExecutor。ThreadPoolExecutor类是java线程池中的核心类。他的实现方式有四种：

public class ThreadPoolExecutor extends AbstractExecutorService {
　　public ThreadPoolExecutor(int corePoolSize,
　　　　int maximumPoolSize,
　　　　long keepAliveTime,
　　　　TimeUnit unit,
　　　　BlockingQueue<Runnable> workQueue) {
　　　　this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
　　　　Executors.defaultThreadFactory(), defaultHandler);
　　}
 
　　　public ThreadPoolExecutor(int corePoolSize,
　　　　int maximumPoolSize,
　　　　long keepAliveTime,
　　　　TimeUnit unit,
　　　　BlockingQueue<Runnable> workQueue,
　　　　ThreadFactory threadFactory) {
　　　　this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
　　　　threadFactory, defaultHandler);
　　}
 
　　public ThreadPoolExecutor(int corePoolSize,
　　　　int maximumPoolSize,
　　　　long keepAliveTime,
　　　　TimeUnit unit,
　　　　BlockingQueue<Runnable> workQueue,
　　　　RejectedExecutionHandler handler) {
　　　　this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
　　　　Executors.defaultThreadFactory(), handler);
　　}
 
　　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.corePoolSize = corePoolSize;
　　　　this.maximumPoolSize = maximumPoolSize;
　　　　this.workQueue = workQueue;
　　　　this.keepAliveTime = unit.toNanos(keepAliveTime);
　　　　this.threadFactory = threadFactory;
　　　　this.handler = handler;
}

通过ThreadPoolExecutor类的源码可以看出，ThreadPoolExecutor类继承AbstractExecutorService，提供四个构造方法，通过构造方法可以看出前面三个最终调了最后一个。
下面介绍下构造方法中的参数：

corePoolSize：线程池的大小。线程池创建之后不会立即去创建线程，而是等待线程的到来。当当前执行的线程数大于该值时，线程会加入到缓冲队列；
maximumPoolSize：线程池中创建的最大线程数；
keepAliveTime：空闲的线程多久时间后被销毁。默认情况下，该值在线程数大于corePoolSize时，对超出corePoolSize值的这些线程起作用。
unit：TimeUnit枚举类型的值，代表keepAliveTime时间单位，可以取下列值：
TimeUnit.HOURS; //小时
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒
workQueue：阻塞队列，用来存储等待执行的任务，决定了线程池的排队策略，有以下取值：
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;
threadFactory：线程工厂，是用来创建线程的。默认new Executors.DefaultThreadFactory();
handler:线程拒绝策略。当创建的线程超出maximumPoolSize，且缓冲队列已满时，新任务会拒绝，有以下取值：
　　ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
　　ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
　　ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
　　ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

以下是具体的实现方式（handler）：

//默认策略。使用该策略时，如果线程池队列满了丢掉这个任务并且抛出RejectedExecutionException异常
class AbortPolicy implements RejectedExecutionHandler{
 
　　public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
　　　　throw new RejectedExecutionException("Task " + r.toString() + 
　　　　" rejected from " + 
　　　　executor.toString()); 
　　}
}
//如果线程池队列满了，会直接丢掉这个任务并且不会有任何异常
class DiscardPolicy implements RejectedExecutionHandler{
 
　　public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
 
　　}
}
//丢弃最老的,会将最早进入队列的任务删掉腾出空间，再尝试加入队列
class DiscardOldestPolicy implements RejectedExecutionHandler{
 
　　public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
　　　　if (!executor.isShutdown()) { 
　　　　　　//移除队头元素 
　　　　　　executor.getQueue().poll(); 
　　　　//再尝试入队 
　　　　　　executor.execute(r); 
　　　　} 
　　}
}
//主线程会自己去执行该任务，不会等待线程池中的线程去执行
class CallerRunsPolicy implements RejectedExecutionHandler{
 
　　public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
　　　　if (!executor.isShutdown()) { 
　　　　　　//直接执行run方法 
　　　　　　r.run(); 
　　　　} 
　　}
}

以下是ThreadPoolExecutor具体的继承结构：

public abstract class AbstractExecutorService implements ExecutorService {
 
}

这是一个抽象类，实现了ExecutorService接口，并实现了ExecutorService里边的方法，下面看下ExecutorService接口的具体实现：

public interface ExecutorService extends Executor {
　　void shutdown();
　　List<Runnable> shutdownNow();
　　boolean isShutdown();
　　boolean isTerminated();
　　boolean awaitTermination(long timeout, TimeUnit unit)
　　throws InterruptedException;
　　<T> Future<T> submit(Callable<T> task);
　　<T> Future<T> submit(Runnable task, T result);
　　Future<?> submit(Runnable task);
　　<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
　　<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
　　long timeout, TimeUnit unit)
　　throws InterruptedException;
　　<T> T invokeAny(Collection<? extends Callable<T>> tasks)
　　throws InterruptedException, ExecutionException;
　　<T> T invokeAny(Collection<? extends Callable<T>> tasks,
　　long timeout, TimeUnit unit)
　　throws InterruptedException, ExecutionException, TimeoutException;
}

ExecutorService继承Executor接口，下面是Executor接口的具体实现：

public interface Executor {
　　void execute(Runnable command);
}

Executor接口是顶层接口，只声明了一个execute方法，该方法是用来执行传递进来的任务的。
回过头来，咱们重新看ThreadPoolExecutor类，该类里边有以下两个重要的方法：

public void execute(Runnable command) {
　　if (command == null)
　　　　throw new NullPointerException();
　　int c = ctl.get();
　　if (workerCountOf(c) < corePoolSize) {
　　　　if (addWorker(command, true))
　　　　　　return;
　　　　c = ctl.get();
　　}
　　if (isRunning(c) && workQueue.offer(command)) {
　　　　int recheck = ctl.get();
　　　　if (! isRunning(recheck) && remove(command))
　　　　　　reject(command);
　　　　else if (workerCountOf(recheck) == 0)
　　　　addWorker(null, false);
　　}else if (!addWorker(command, false))
　　　　reject(command);
}

public <T> Future<T> submit(Callable<T> task) {
　　if (task == null) throw new NullPointerException();
　　RunnableFuture<T> ftask = newTaskFor(task);
　　execute(ftask);
　　return ftask;
}

execute()方法是Executor中声明的方法，在ThreadPoolExecutor有了具体的实现，这个方法是ThreadPoolExecutor的核心方法，
通过这个方法可以向线程池提交一个任务，交由线程池去执行
submit()方法是ExecutorService中声明的方法，在AbstractExecutorService中进行了实现，Executor中并没有对其进行重写。从实现中可以看出，submit方法最终也调用了execute方法，也是执行一个人去，但submit方法可以返回执行结果，利用Future来获取任务执行结果。

2.2 Spring中的线程池

Spring中的线程池是由ThreadPoolTaskExecutor类来实现的。该类的实现原理最终也是调用了java中的ThreadPoolExecutor类中的一些方法。具体的实现读者可以自己去翻阅Spring的源码，这里笔者就不罗列了。我们看下ThreadPoolTaskExecutor的初始化。
ThreadPoolTaskExecutor有两种常用的初始化方式：xml配置，java代码初始化
Xml配置：

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="5" />
<property name="keepAliveSeconds" value="200" />
<property name="maxPoolSize" value="10" />
<property name="queueCapacity" value="20" />
<property name="rejectedExecutionHandler">
<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
</property>
</bean>

Java代码初始化：

private void test2(){
　　ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
　　executor.setCorePoolSize(10);
　　executor.setMaxPoolSize(15);
　　executor.setKeepAliveSeconds(1);
　　executor.setQueueCapacity(5);
　　executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
　　executor.initialize();
　　executor.execute(new Runnable(){
　　　　@Override
　　　　public void run() {
　　　　　　//执行的代码
　　　　}
　　});
}

3.3 线程池中常用参数（ThreadPoolExecutor）

corePoolSize：核心线程数

核心线程会一直存活，即使没有任务需要执行
当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理
设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭

queueCapacity：任务队列容量（阻塞队列）

当核心线程数达到最大时，新任务会放在队列中排队等待执行

maxPoolSize：最大线程数

当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务
当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常

keepAliveTime：线程空闲时间

当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize
如果allowCoreThreadTimeout=true，则会直到线程数量=0

allowCoreThreadTimeout：允许核心线程超时
rejectedExecutionHandler：任务拒绝处理器
* 两种情况会拒绝处理任务：
- 当线程数已经达到maxPoolSize，切队列已满，会拒绝新任务
- 当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务
* 线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy，会抛出异常
* ThreadPoolExecutor类有几个内部实现类来处理这类情况：
- AbortPolicy 丢弃任务，抛运行时异常
- CallerRunsPolicy 执行任务
- DiscardPolicy 忽视，什么都不会发生
- DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
* 实现RejectedExecutionHandler接口，可自定义处理器

3.4 ThreadPoolExecutor执行顺序

线程池按以下行为执行任务
1. 当线程数小于核心线程数时，创建线程。
2. 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
3. 当线程数大于等于核心线程数，且任务队列已满
- 若线程数小于最大线程数，创建线程
- 若线程数等于最大线程数，抛出异常，拒绝任务

3.5 如何设置参数

默认值
* corePoolSize=1
* queueCapacity=Integer.MAX_VALUE
* maxPoolSize=Integer.MAX_VALUE
* keepAliveTime=60s
* allowCoreThreadTimeout=false
* rejectedExecutionHandler=AbortPolicy()
2. 如何来设置
* 需要根据几个值来决定
- tasks ：每秒的任务数，假设为500~1000
- taskcost：每个任务花费时间，假设为0.1s
- responsetime：系统允许容忍的最大响应时间，假设为1s
* 做几个计算
- corePoolSize = 每秒需要多少个线程处理？
* threadcount = tasks/(1/taskcost) =tasks*taskcout = (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50
* 根据8020原则，如果80%的每秒任务数小于800，那么corePoolSize设置为80即可
- queueCapacity = (coreSizePool/taskcost)responsetime
* 计算可得 queueCapacity = 80/0.11 = 800。意思是队列里的线程可以等待1s，超过了的需要新开线程来执行
* 切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时，不能新开线程来执行，响应时间会随之陡增。
- maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)
* 计算可得 maxPoolSize = (1000-800)/10 = 20
* （最大任务数-队列容量）/每个线程每秒处理能力 = 最大线程数
- rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理
- keepAliveTime和allowCoreThreadTimeout采用默认通常能满足
3. 以上都是理想值，实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了，则需要通过升级硬件和优化代码，降低taskcost来处理。

3.6 core满了以后会怎么样

新来的请求会进入阻塞队列

3.7 如果没有设置core这些，不断的有请求，会发生什么

默认值

corePoolSize=1
queueCapacity=Integer.MAX_VALUE
maxPoolSize=Integer.MAX_VALUE
keepAliveTime=60s
allowCoreThreadTimeout=false
rejectedExecutionHandler=AbortPolicy()

线程池里面的参数都是有默认值的（不设置的时候）,当有不断的请求时，会先将core不能及时处理的线程放入任务队列里面，当任务队列满时，且当前线程数小于最大线程数时，线程池会创建新的线程来处理。当请求线程大于最大线程数时，线程池会拒绝处理并抛出异常.

每天多学一点点.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java.util.concurrent解析及线程池常用参数

1 java.util.concurrent1.1 主要部件java.util.concurrent中包含了太多的功能，在本文中，我们将主要关注此包中一些最有用的实用程序，如：• Executor• ExecutorService• ScheduledExecutorService• Future• CountDownLatch• CyclicBarrier• S...
复制链接

扫一扫

专栏目录