线程池(3)Executors.newCachedThreadPool

例子:

ExecutorService es = Executors.newCachedThreadPool();
        try {
            for (int i = 0; i < 20; i++) {
                Runnable syncRunnable = new Runnable() {
                    @Override
                    public void run() {
                        log.info(Thread.currentThread().getName());
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                es.execute(syncRunnable);
            }
        } finally {
            es.shutdown();
        }

运行结果:

            10:21:04.610 pool-1-thread-13
            10:21:04.612 pool-1-thread-3
            10:21:04.612 pool-1-thread-7
            10:21:04.612 pool-1-thread-2
            10:21:04.610 pool-1-thread-14
            10:21:04.612 pool-1-thread-6
            10:21:04.611 pool-1-thread-8
            10:21:04.611 pool-1-thread-11
            10:21:04.611 pool-1-thread-4
            10:21:04.610 pool-1-thread-1
            10:21:04.611 pool-1-thread-20
            10:21:04.611 pool-1-thread-12
            10:21:04.610 pool-1-thread-16
            10:21:04.611 pool-1-thread-5
            10:21:04.611 pool-1-thread-9
            10:21:04.610 pool-1-thread-17
            10:21:04.610 pool-1-thread-18
            10:21:04.610 pool-1-thread-10
            10:21:04.611 pool-1-thread-15
            10:21:04.611 pool-1-thread-19

调用的调用的ThreadPoolExecutor:

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

corePoolSize=0,maximumPoolSize=Integer.MAX_VALUE

keepAliveTime=60秒

allowCoreThreadTimeout=false(默认)

因此,

  • 核心线程数为0
  • 每来一个任务,先查看缓冲池中是否有可用线程(没超过60秒的),如果有,则用;没有,则就创建一个新线程
  • 因为核心线程数为0,池中的线程当达到60秒时,会超时关闭,直到核心线程数=0

原文地址:https://www.cnblogs.com/yaoyuan2/p/9606504.html

时间: 2024-08-06 09:51:40

线程池(3)Executors.newCachedThreadPool的相关文章

线程池之 Executors

线程池之 Executors + 面试题 线程池的创建分为两种方式:ThreadPoolExecutor 和 Executors,上一节学习了 ThreadPoolExecutor 的使用方式,本节重点来看 Executors 是如何创建线程池的. Executors 可以创建以下六种线程池. FixedThreadPool(n):创建一个数量固定的线程池,超出的任务会在队列中等待空闲的线程,可用于控制程序的最大并发数. CachedThreadPool():短时间内处理大量工作的线程池,会根据

Android线程池(一)——Executors(线程池)以及FutureTask使用示例

MainActivity如下: package cc.vv; import java.util.ArrayList; import java.util.Iterator; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.FutureTask; im

JAVA线程池 之 Executors (一)

一.背景 线程属于系统稀缺资源,在使用线程时,如果无限制创建线程,达到CPU高负荷时,会导致系统运行缓慢,更有甚者直接宕机. 在这样的基础上我们希望在使用线程时,竟可能使系统线程数处于一个可控范围,尽可能实现线程的重用. 二.Executors 分析 Executors 示例  DEMO /** * @author binH * @date 2018/01/24 */ package org.lsnbin.thread; import java.util.concurrent.ExecutorS

线程池(2)-Executors提供4个线程池

1.为什么不使用Executors提供4个线程池创建线程池 阿里巴巴开放手册这样写: 4. [强制]线程池不允许使用 Executors 去创建,而是通过 ThreadPoolExecutor 的方式,这样 的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险. 说明:Executors 返回的线程池对象的弊端如下: 1)FixedThreadPool 和 SingleThreadPool: 允许的请求队列长度为 Integer.MAX_VALUE,可能会堆积大量的请求,从而导致 O

JAVA线程池 之 Executors (二) 原理分析

一.线程池状态 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static final int COUNT_BITS = Integer.SIZE - 3; private static final int CAPACITY = (1 << COUNT_BITS) - 1; // runState is stored in the high-order bits private s

Executors、ThreadPoolExecutor线程池使用

Executors:JDK给提供的线程工具类,静态方法构建线程池服务ExecutorService,也就是ThreadPoolExecutor,使用默认线程池配置参数. 建议:对于大用户,高并发,不易掌控的项目,不建议使用Executors来创建线程池对象. 对于易于掌控且并发数不高的项目,可以考虑Executors. ThreadPoolExecutor:线程池对象,实现ExecutorService接口,可以自定义线程池核心线程数.最大线程数.空闲时间.缓冲队列等. 建议:大用户,高并发,不

深入理解Java之线程池

原作者:海子 出处:http://www.cnblogs.com/dolphin0520/ 本文归作者海子和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利. 在前面的文章中,我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间. 那么有没有一种办法使得线程可

java多线程、线程池的实现

Java实现多线程的3种方法:继承Thread类.实现runnable接口.使用ExecutorService,Callable.Future实现有返回值的多线程.前2种线程的实现方式没有返回值,第三种实现方式可以获取线程执行的返回值. 一:继承java.lang.Thread类 public class MyThread extends Thread { @Override public void run() { System.out.println( "my thread begin.&qu

12.ThreadPoolExecutor线程池原理及其execute方法

jdk1.7.0_79  对于线程池大部分人可能会用,也知道为什么用.无非就是任务需要异步执行,再者就是线程需要统一管理起来.对于从线程池中获取线程,大部分人可能只知道,我现在需要一个线程来执行一个任务,那我就把任务丢到线程池里,线程池里有空闲的线程就执行,没有空闲的线程就等待.实际上对于线程池的执行原理远远不止这么简单. 在Java并发包中提供了线程池类——ThreadPoolExecutor,实际上更多的我们可能用到的是Executors工厂类为我们提供的线程池:newFixedThread

[转]深入理解Java之线程池

出处:http://www.cnblogs.com/dolphin0520/ 本文归作者海子和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利. 在前面的文章中,我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间. 那么有没有一种办法使得线程可以复用,就是执