Java通过Executors提供四种线程池

本文深入探讨了Java中四种线程池的创建与使用:可缓存线程池、定长线程池、定时线程池和单线程化线程池。通过代码示例展示了每种线程池的特点,并强调了避免使用Executors创建线程池,推荐使用ThreadPoolExecutor以更好地控制线程池的运行规则。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。 newSingleThreadExecutor创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

每个线程例子:

        ExecutorService e = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            e.submit(() -> {
                String name = Thread.currentThread().getName();
                System.out.println("使用CachedThread创建线程:" + name);
            });
        }

        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int j = 0; j < 5; j++) {
            executorService.submit(() -> {
                String name = Thread.currentThread().getName();
                System.out.println("使用FixedThread创建线程:" + name);
            });
        }

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        for (int k = 0; k < 5; k++) {
            scheduledExecutorService.schedule(() -> {
                String name = Thread.currentThread().getName();
                System.out.println("使用ScheduledThread创建线程:" + name);
                System.out.println(System.currentTimeMillis());
            }, 2, TimeUnit.SECONDS);
        }


        ExecutorService singleTHread = Executors.newSingleThreadExecutor();
        for (int n = 0; n < 5; n++) {
            singleTHread.submit(() -> {
                String name = Thread.currentThread().getName();
                System.out.println("使用SingleThread创建线程:" + name);
            });
        }
    输出:
    使用CachedThread创建线程:pool-1-thread-1
    使用CachedThread创建线程:pool-1-thread-1
    使用CachedThread创建线程:pool-1-thread-1
    使用CachedThread创建线程:pool-1-thread-1
    使用CachedThread创建线程:pool-1-thread-1
    使用FixedThread创建线程:pool-2-thread-1
    使用FixedThread创建线程:pool-2-thread-2
    使用FixedThread创建线程:pool-2-thread-3
    使用FixedThread创建线程:pool-2-thread-1
    使用FixedThread创建线程:pool-2-thread-2
    使用SingleThread创建线程:pool-4-thread-1
    使用SingleThread创建线程:pool-4-thread-1
    使用SingleThread创建线程:pool-4-thread-1
    使用SingleThread创建线程:pool-4-thread-1
    使用SingleThread创建线程:pool-4-thread-1
    使用ScheduledThread创建线程:pool-3-thread-1
    使用ScheduledThread创建线程:pool-3-thread-3
    1550728498308
    使用ScheduledThread创建线程:pool-3-thread-2
    1550728498308
    使用ScheduledThread创建线程:pool-3-thread-3
    1550728498308
    1550728498308
    使用ScheduledThread创建线程:pool-3-thread-2
    1550728498309

       ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
        ExecutorService pool = new ThreadPoolExecutor(2, 8,
                1L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(20), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
        for (int n = 0; n < 20; n++) {
            pool.submit(() -> {
                String name = Thread.currentThread().getName();
                System.out.println("使用ThreadPoolExecutor创建线程:" + name);
                System.out.println(pool.toString());
            });
        }
    

阿里编程规范提示: 线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。 说明:Executors各个方法的弊端: 1)newFixedThreadPool和newSingleThreadExecutor: 主要问题是堆积的请求处理队列可能会耗费非常大的内存,甚至OOM。 2)newCachedThreadPool和newScheduledThreadPool: 主要问题是线程数最大数是Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至OOM。

Positive example 1:

    //org.apache.commons.lang3.concurrent.BasicThreadFactory
    ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
        new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());

Positive example 2:

    ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
        .setNameFormat("demo-pool-%d").build();

    //Common Thread Pool
    ExecutorService pool = new ThreadPoolExecutor(5, 200,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    pool.execute(()-> System.out.println(Thread.currentThread().getName()));
    pool.shutdown();//gracefully shutdown

Positive example 3:

    <bean id="userThreadPool"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="10" />
        <property name="maxPoolSize" value="100" />
        <property name="queueCapacity" value="2000" />

    <property name="threadFactory" value= threadFactory />
        <property name="rejectedExecutionHandler">
            <ref local="rejectedExecutionHandler" />
        </property>
    </bean>
    //in code
    userThreadPool.execute(thread);

转载于:https://my.oschina.net/u/563488/blog/3012970

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值