ThreadPoolExecutor 使用

最新推荐文章于 2024-06-20 20:46:49 发布

new HashMap

最新推荐文章于 2024-06-20 20:46:49 发布

阅读量993

点赞数

分类专栏： Java多线程

Java多线程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

public class ThreadPoolExecutorTest implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName() + "start");
        long start = System.currentTimeMillis();
        int i = (int)(Math.random() * 1000);
        try {
            TimeUnit.MILLISECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName() + "end" + "用时：" + (end - start));
    }

}

public class Entrance {
    private static BlockingQueue blockingQueue = new ArrayBlockingQueue<>(10);
    private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 15, 10, TimeUnit.SECONDS, blockingQueue);

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test1();
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("************** 分割线 **************");
        test1();
    }
    public static void test1() {
        ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
        for (int i = 0; i < 15; i++) {
            threadPoolExecutor.execute(test);
        }
    }
}

运行结果：线程池只开启了5个线程，其余进入阻塞队列，阻塞队列的大小为10。

pool-1-thread-1start
pool-1-thread-2start
pool-1-thread-3start
pool-1-thread-4start
pool-1-thread-5start
pool-1-thread-5end用时：14
pool-1-thread-5start
pool-1-thread-4end用时：384
pool-1-thread-4start
pool-1-thread-5end用时：387
pool-1-thread-5start
pool-1-thread-3end用时：413
pool-1-thread-3start
pool-1-thread-1end用时：702
pool-1-thread-1start
pool-1-thread-2end用时：827
pool-1-thread-2start
pool-1-thread-1end用时：151
pool-1-thread-1start
pool-1-thread-3end用时：476
pool-1-thread-3start
pool-1-thread-5end用时：590
pool-1-thread-5start
pool-1-thread-2end用时：347
pool-1-thread-2start
pool-1-thread-3end用时：380
pool-1-thread-2end用时：152
pool-1-thread-4end用时：982
pool-1-thread-5end用时：521
pool-1-thread-1end用时：698
************** 分割线 **************
pool-1-thread-3start
pool-1-thread-5start
pool-1-thread-4start
pool-1-thread-2start
pool-1-thread-1start
pool-1-thread-2end用时：180
pool-1-thread-2start
pool-1-thread-3end用时：514
pool-1-thread-3start
pool-1-thread-1end用时：651
pool-1-thread-1start
pool-1-thread-4end用时：728
pool-1-thread-4start
pool-1-thread-2end用时：598
pool-1-thread-2start
pool-1-thread-1end用时：131
pool-1-thread-1start
pool-1-thread-3end用时：274
pool-1-thread-3start
pool-1-thread-2end用时：34
pool-1-thread-2start
pool-1-thread-3end用时：155
pool-1-thread-3start
pool-1-thread-5end用时：959
pool-1-thread-5start
pool-1-thread-1end用时：338
pool-1-thread-5end用时：215
pool-1-thread-3end用时：480
pool-1-thread-4end用时：889
pool-1-thread-2end用时：917

在web开发中，服务器需要接受并处理请求，所以会为一个请求来分配一个线程来进行处理。如果每次请求都新创建一个线程的话实现起来非常简便，但是存在一个问题：

如果并发的请求数量非常多，但每个线程执行的时间很短，这样就会频繁的创建和销毁线程，如此一来会大大降低系统的效率。可能出现服务器在为每个请求创建新线程和销毁线程上花费的时间和消耗的系统资源要比处理实际的用户请求的时间和资源更多。

什么时候使用线程池？

单个任务处理时间比较短
需要处理的任务数量很大

使用线程池的好处

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

下面再介绍下线程池的运行状态. 线程池一共有五种状态, 分别是:

RUNNING ：能接受新提交的任务，并且也能处理阻塞队列中的任务；
SHUTDOWN：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务。在线程池处于 RUNNING 状态时，调用 shutdown()方法会使线程池进入到该状态。（finalize() 方法在执行过程中也会调用shutdown()方法进入该状态）；
STOP：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于 RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态；
TIDYING：如果所有的任务都已终止了，workerCount (有效线程数) 为0，线程池进入该状态后会调用 terminated() 方法进入TERMINATED 状态。
TERMINATED：在terminated() 方法执行完后进入该状态，默认terminated()方法中什么也没有做。
进入TERMINATED的条件如下：
- 线程池不是RUNNING状态；
- 线程池状态不是TIDYING状态或TERMINATED状态；
- 如果线程池状态是SHUTDOWN并且workerQueue为空；
- workerCount为0；
- 设置TIDYING状态成功。

ThreadPoolExecutor构造方法

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

构造方法中的字段含义如下：

corePoolSize：核心线程数量，当有新任务在execute()方法提交时，会执行以下判断：
1. 如果运行的线程少于 corePoolSize，则创建新线程来处理任务，即使线程池中的其他线程是空闲的；
2. 如果线程池中的线程数量大于等于 corePoolSize 且小于 maximumPoolSize，则只有当workQueue满时才创建新的线程去处理任务；
3. 如果设置的corePoolSize 和 maximumPoolSize相同，则创建的线程池的大小是固定的，这时如果有新任务提交，若workQueue未满，则将请求放入workQueue中，等待有空闲的线程去从workQueue中取任务并处理；
4. 如果运行的线程数量大于等于maximumPoolSize，这时如果workQueue已经满了，则通过handler所指定的策略来处理任务；
所以，任务提交时，判断的顺序为 corePoolSize –> workQueue –> maximumPoolSize。
maximumPoolSize：最大线程数量；
workQueue：等待队列，当任务提交时，如果线程池中的线程数量大于等于corePoolSize的时候，把该任务封装成一个Worker对象放入等待队列；当提交一个新的任务到线程池以后, 线程池会根据当前线程池中正在运行着的线程的数量来决定对该任务的处理方式，主要有以下几种处理方式:
1. 直接切换：这种方式常用的队列是SynchronousQueue，但现在还没有研究过该队列，这里暂时还没法介绍；
2. 使用无界队列：一般使用基于链表的阻塞队列LinkedBlockingQueue。如果使用这种方式，那么线程池中能够创建的最大线程数就是corePoolSize，而maximumPoolSize就不会起作用了（后面也会说到）。当线程池中所有的核心线程都是RUNNING状态时，这时一个新的任务提交就会放入等待队列中。
3. 使用有界队列：一般使用ArrayBlockingQueue。使用该方式可以将线程池的最大线程数量限制为maximumPoolSize，这样能够降低资源的消耗，但同时这种方式也使得线程池对线程的调度变得更困难，因为线程池和队列的容量都是有限的值，所以要想使线程池处理任务的吞吐率达到一个相对合理的范围，又想使线程调度相对简单，并且还要尽可能的降低线程池对资源的消耗，就需要合理的设置这两个数量。
  - 如果要想降低系统资源的消耗（包括CPU的使用率，操作系统资源的消耗，上下文环境切换的开销等）, 可以设置较大的队列容量和较小的线程池容量, 但这样也会降低线程处理任务的吞吐量。
  - 如果提交的任务经常发生阻塞，那么可以考虑通过调用 setMaximumPoolSize() 方法来重新设定线程池的容量。
  - 如果队列的容量设置的较小，通常需要将线程池的容量设置大一点，这样CPU的使用率会相对的高一些。但如果线程池的容量设置的过大，则在提交的任务数量太多的情况下，并发量会增加，那么线程之间的调度就是一个要考虑的问题，因为这样反而有可能降低处理任务的吞吐量。
keepAliveTime：线程池维护线程所允许的空闲时间。当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime；
threadFactory：它是ThreadFactory类型的变量，用来创建新线程。默认使用Executors.defaultThreadFactory() 来创建线程。使用默认的ThreadFactory来创建线程时，会使新创建的线程具有相同的NORM_PRIORITY优先级并且是非守护线程，同时也设置了线程的名称。
handler：它是RejectedExecutionHandler类型的变量，表示线程池的饱和策略。如果阻塞队列满了并且没有空闲的线程，这时如果继续提交任务，就需要采取一种策略处理该任务。线程池提供了4种策略：
1. AbortPolicy：直接抛出异常，这是默认策略；
2. CallerRunsPolicy：用调用者所在的线程来执行任务；
3. DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
4. DiscardPolicy：直接丢弃任务；

execute方法执行过程

如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务；
如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中；
如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务；
如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。

以上文字内容转载自（非常好的一个个人博客，各种源码的分析）：http://www.ideabuffer.cn/2017/04/04/%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3Java%E7%BA%BF%E7%A8%8B%E6%B1%A0%EF%BC%9AThreadPoolExecutor/

new HashMap

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadPoolExecutor 使用

public class ThreadPoolExecutorTest implements Runnable { @Override public void run() { // TODO Auto-generated method stub System.out.println(Thread.currentThread().getName()...
复制链接

扫一扫

专栏目录