并发编程-concurrent指南-线程池ExecutorService的实例

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量79 收藏
点赞数
文章标签： java git
原文链接：http://www.cnblogs.com/qjm201000/p/10156262.html
版权

1、new Thread的弊端

执行一个异步任务你还只是如下new Thread吗？

new Thread(new Runnable() {

    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}).start();

那你就out太多了，new Thread的弊端如下：
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

 

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 

 

1.CachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程

 

public class ThreadRunner implements Runnable{
    private int num;
　　 private int timeout;
    public ThreadRunner(int num,int timeout){
        this.num = num;
        this.timeout = timeout;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":运行中,"+num);
try {
    　　　　TimeUnit.SECONDS.sleep(timeout);
　　　　 } catch (InterruptedException e) {
 　　　　e.printStackTrace();
　　　　 }
    }
}

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CacheThreadPoolMain {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        for(int i = 1;i<21;i++){
            pool.submit(new ThreadRunner(i,0));
        }
        pool.shutdown();
    }
}

结果：

pool-1-thread-1:运行中,1
pool-1-thread-5:运行中,5
pool-1-thread-2:运行中,2
pool-1-thread-7:运行中,7
pool-1-thread-4:运行中,4
pool-1-thread-9:运行中,9
pool-1-thread-3:运行中,3
pool-1-thread-10:运行中,10
pool-1-thread-8:运行中,8
pool-1-thread-6:运行中,6
pool-1-thread-12:运行中,12
pool-1-thread-11:运行中,11
pool-1-thread-13:运行中,13
pool-1-thread-9:运行中,14
pool-1-thread-10:运行中,20
pool-1-thread-13:运行中,15
pool-1-thread-8:运行中,19
pool-1-thread-11:运行中,16
pool-1-thread-6:运行中,18
pool-1-thread-12:运行中,17

总结
- 池中线程时随着处理数据增加而增加
- 线程数并不是一直增加，如果有新任务需要执行时，首先查询池中是否有空闲线程并且还为到空闲截止时间，如果有，则使用空闲线程，如果没有，则创建新线程并放入池中。
- 用于执行一些生存期很短的异步型任务。不适用于IO等长延时操作，因为这可能会创建大量线程，导致系统崩溃。
- 使用SynchronousQueue作为阻塞队列，如果有新任务进入队列，必须队列中数据被其他线程处理，否则会等待。

 

2.FixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

import java.util.concurrent.TimeUnit;

public class ThreadRunner implements Runnable{
    private int num;
    private int timeout;
    public ThreadRunner(int num,int timeout){
        this.num = num;
        this.timeout = timeout;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":运行中,"+num);
        try {
            TimeUnit.SECONDS.sleep(timeout);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolMain {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(3);//有一个固定大小的线程池

        for(int i = 1;i<21;i++){
            pool.submit(new ThreadRunner(i,2));
        }

        pool.shutdown();
    }
}

总结：
- 池中线程数量固定，不会发生变化
- 使用无界的LinkedBlockingQueue，要综合考虑生成与消费能力，生成过剩，可能导致堆内存溢出。
- 适用一些很稳定很固定的正规并发线程，多用于服务器

 

 

3.ScheduledExcutorPool

创建一个定长线程池，支持定时及周期性任务执行。

ScheduledThreadPool中常用的ScheduleAtFixedRate和ScheduleWithFixedDelay

 

* ScheduleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔，
*                     即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2*period, …；
* ScheduleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，
*                     即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay
*
* ScheduleAtFixedRate 是基于固定时间间隔进行任务调度，
* ScheduleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度

 

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class ThreadRunner implements Runnable{
    private final SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss.SSS");

    private int num;
    private int timeout;
    public ThreadRunner(int num,int timeout){
        this.num = num;
        this.timeout = timeout;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":当前时间："+format.format(new Date())+",运行中,"+num);
        try {
            TimeUnit.SECONDS.sleep(timeout);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExcutorPoolMain {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);//线程池

        // 从现在开始5秒钟之后，每隔10秒钟执行一次ThreadRunner
        pool.scheduleAtFixedRate(new ThreadRunner(2,3), 5,10, TimeUnit.SECONDS);

        // 从现在开始5秒钟之后，每隔10秒钟执行一次job2
        pool.scheduleWithFixedDelay(new ThreadRunner(3,3), 5, 10, TimeUnit.SECONDS);

        /**
         * ScheduleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔，
         *                     即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2*period, …；
         * ScheduleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，
         *                     即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay
         *
         * ScheduleAtFixedRate 是基于固定时间间隔进行任务调度，
         * ScheduleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度
         */
    }
}

总结：
- 线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
- 只有当调度任务来的时候,ScheduledExecutorService才会真正启动一个线程,其余时间ScheduledExecutorService都是出于轮询任务的状态

 

 

4.SingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照提交顺序被执行

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class ThreadRunner implements Runnable{
    private final SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss.SSS");

    private int num;
    private int timeout;
    public ThreadRunner(int num,int timeout){
        this.num = num;
        this.timeout = timeout;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":当前时间："+format.format(new Date())+",运行中,"+num);
        try {
            TimeUnit.SECONDS.sleep(timeout);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadPool {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        for(int i=1;i<21;i++){
            pool.submit(new ThreadRunner(i,5));
        }
        pool.shutdown();
    }
}

结果：

pool-1-thread-1:当前时间：15:53:35.883,运行中,1
pool-1-thread-1:当前时间：15:53:40.884,运行中,2
pool-1-thread-1:当前时间：15:53:45.884,运行中,3
pool-1-thread-1:当前时间：15:53:50.884,运行中,4
pool-1-thread-1:当前时间：15:53:55.884,运行中,5
pool-1-thread-1:当前时间：15:54:00.885,运行中,6
pool-1-thread-1:当前时间：15:54:05.885,运行中,7
pool-1-thread-1:当前时间：15:54:10.886,运行中,8
pool-1-thread-1:当前时间：15:54:15.886,运行中,9
pool-1-thread-1:当前时间：15:54:20.887,运行中,10
pool-1-thread-1:当前时间：15:54:25.887,运行中,11
pool-1-thread-1:当前时间：15:54:30.887,运行中,12
pool-1-thread-1:当前时间：15:54:35.888,运行中,13
pool-1-thread-1:当前时间：15:54:40.888,运行中,14
pool-1-thread-1:当前时间：15:54:45.888,运行中,15
pool-1-thread-1:当前时间：15:54:50.888,运行中,16
pool-1-thread-1:当前时间：15:54:55.889,运行中,17
pool-1-thread-1:当前时间：15:55:00.889,运行中,18
pool-1-thread-1:当前时间：15:55:05.889,运行中,19
pool-1-thread-1:当前时间：15:55:10.890,运行中,20

 

总结：
- 线程中只有一个线程在执行
- 适用于有明确执行顺序但是不影响主线程的任务，压入池中的任务会按照队列顺序执行。
- 使用无界的LinkedBlockingQueue，要综合考虑生成与消费能力，生成过剩，可能导致堆内存溢出。

 

 

源码地址：https://github.com/qjm201000/concurrent_executorService.git

 

转载于:https://www.cnblogs.com/qjm201000/p/10156262.html

weixin_30825581
关注
运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接
w969272198的专栏
10-08 3026
最近在项目中可能要用到socket相关的东西来发送消息，所以初步研究了下socket的TCP和UDP实现方式，并且结合java1.5的concurrent.ExecutorService类来实现多线程。 具体实现方式见代码： 一、TCP方式： 1、服务端实现方式： TCP的服务端实现方式主要用到ServerSocket类，接收等待客户端连接的方法是accept(); 代码如下：类Sock
Java-concurrent之ExecutorService
夫礼者的专栏
09-30 1921
为了能够更好地控制多线程，JDK提供了一套Executor框架，帮助开发人员有效地进行线程控制，其本质就是一个线程池。
java源码学习——concurrent.ExecutorService
weixin_38522681的博客
10-26 313
这里写目录标题介绍ExecutorService种类newSingleThreadExecutor——单线程化线程池newFixedThreadPool——定长线程池newCachedThreadPool——可缓存线程池newScheduledThreadPool——支持定时及周期性任务执行的线程池 介绍 ExecutorService是java.util.concurrent包中的一个线程池实现接口。其有两个实现类： 1）ThreadPoolExecutor：普通线程池通过配置线程池大小，能有效管理线程
试用concurrent包下的Executors，ExecutorService，CountDownLatch
lkforce
04-14 544
用concurrent包下的Executors，ExecutorService，CountDownLatch类写了一小段程序，研究了研究这几个类的功能，代码如下： package test; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import ja
Java并发包：ExecutorService和ThreadPoolExecutor
热门推荐
charming的专栏
07-12 1万+
文章译自：http://tutorials.jenkov.com/java-util-concurrent/index.html 抽空翻译了一下这个教程的文章，后面会陆续放出，如有不妥，请批评指正。 转自请注明出处。 ExecutorServiceJava.util.concurrent.ExecutorService接口代表一种异步执行机制，它能够在后台执行任务。因此ExecutorSer
java并发编程实战源码-concurrent-programming:《Java并发编程实战》源码整理
05-25
《Java并发编程实战》这本书是Java并发编程领域的一本经典之作，它深入浅出地讲解了如何在Java环境中高效、安全地进行多线程...这个源码库包含了各种并发编程模式和技巧的实例，是加深理论理解、提升实践能力的好材料。
java并发编程源码-Concurrent-Programming-with-Java-and-OpenMP:并发编程分配源代码
05-24
本资源“Concurrent-Programming-with-Java-and-OpenMP”提供了Java和OpenMP两种并发编程技术的源码实例，帮助开发者深入理解并发编程的实践与原理。 在Java中，Java并发API（Java Concurrency API）是实现并发编程...
java-concurrent:java 并发编程例子
06-28
通过这些实例，你可以更好地理解Java并发编程的实践技巧和最佳实践。 总之，Java并发编程是一门深奥的学问，它涉及到线程安全、同步机制、线程池管理等多个方面。熟练掌握`java.util.concurrent`包中的工具和原理，...
并发编程 - 线程池ThreadPoolExecutor、自定义实现线程池、定时任务、并发安全
weixin_42666318的博客
05-05 659
为什么要使用线程池？ 在Java中，创建一个线程只需要通过 new Thread()，就可以创建一个线程。那么创建一个线程需要经历以下几个步骤： 1、创建（T1：向操作系统申请内存） 2、运行（T2：执行run方法中业务） 3、销毁（T3：销毁当前线程并释放资源） 所以，在每一次new出一个线程需要消耗的时间为T1+T2+T3，可以发现，只有运行的业务不同，其他时间都不属于业务处理时间，因此...
java并发编程源码-Java-Programs-Source-Code:并发和并行编程，具有线程池，forkJoin，同步，信号量，Reen
05-24
Java并发编程是Java开发中的重要领域，涉及到多线程、线程池、同步机制、并发工具类等核心概念。在Java-Programs-Source-Code-master这个压缩包中，我们很可能会找到一系列与这些主题相关的源代码示例，这对于深入...
concurrent之线程池executorService和forkJoin用法
Seven71111的博客
03-10 460
executorService：线程池 根据cpu核数设置线程池线程个数，编写任务类 代码如下： package com.demo; import java.util.ArrayList; import java.util.concurrent.*; import java.util.stream.LongStream; /** * @Description * @Author b...
Java多线程工具包java.util.concurrent---ExecutorService
upxiaofeng的专栏
11-23 2321
什么是ExecutorService java.util.concurrent.ExecutorService 接口表示一个异步执行机制，使我们能够在后台执行任务。因此一个 ExecutorService 很类似于一个线程池。实际上，存在于 java.util.concurrent 包里的 ExecutorService 实现就是一个线程池实现。 ExecutorService的实现 E...
使用java.util.concurrent.ExecutorService实现Java线程异步执行
江湖小虾米
08-07 4427
Java异步执行方法： 首先搞个最简单线程实现Runnable接口 public class SimpleRunner implements Runnable { int runIndex = 0; public void setRunIndex(int runIndex) { this.runIndex = runIndex; } public voi
ExecutorService 线程池及 Callable, Future, CompletableFuture
yichudu
01-28 1206
1.ThreadPoolExecutor java.util.concurrent.ThreadPoolExecutor 类。用于接收提交的任务，放到线程池中运行。 java.util.concurrent.ThreadPoolExecutor.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAlive
例子分析java.util.concurrent.ExecutorService
M=54G
07-15 2364
前言：ExecutorService是一个Executor，官方解释是An object that executes submitted Runnable tasks...This interface provides a way of decoupling task submission from the mechanics of how each task will be run, inclu
java.util.concurrent 之Executors
sun
05-11 1737
java.util.concurrent.Executor, java.util.concurrent.ExecutorService, java.util.concurrent. Executors 这三者均是 Java Executor 框架的一部分，用来提供线程池的功能。因为创建和管理线程非常心累，并且操作系统通常对线程数有限制，所以建议使用线程池来并发执行任务，而不是每次请求进来时创建
java concurrent 探秘
MyKM
04-16 732
java concurrent 探秘(转) 我们都知道，在JDK1.5之前，Java中要进行业务并发时，通常需要有程序员独立完成代码实现，当然也有一些开源的框架提供了这些功能，但是这些依然没有JDK自带的功能使用起来方便。而当针对高质量Java多线程并发程序设计时,为防止死蹦等现象的出现，比如使用java之前的wait()、notify()和synchronized等，每每需要考虑性能、死锁...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 96
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值