java中常用的五种线程池的实现

最新推荐文章于 2024-09-23 16:28:51 发布
最新推荐文章于 2024-09-23 16:28:51 发布
阅读量2.9k 收藏 8
点赞数 1
分类专栏： java 文章标签： java 多线程 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_16381803/article/details/52193968
版权

线程池介绍：

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，
增加处理器单元的吞吐能力。 假设一个服务器完成一项任务所需时间为：T1 创建线程时间， T2 在
线程中执行任务的时间，T3 销毁线程时间。

涉及的接口与类：

一.Java中的ThreadPoolExecutor类（该类有四种构造方法）

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);

     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);

   public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);

   public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

二.Java中的ExecutorService接口

可缓存线程池
Executors.newCachedThreadPool();

定长线程池
Executors.newFixedThreadPool(3);

定长线程池，定时器
  Executors.newScheduledThreadPool(3);

单线程化的线程池
Executors.newSingleThreadExecutor();

三.Java中的ScheduledExecutorService接口


代码实现：代码中已经对各个方法有详细的注释，请仔细阅读注释；



package com.superb.juint_thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 该类中有五种实现线程池的方法，其中有三种通过ExecutorServic接口实现，一种
 * 通过ScheduledExecutorService接口实现，另一种通过ThreadPoolExecutor类实现
 * 
 * 这里面将五种线程池用单例模式实现，当然也没必要用单例模式实现，这个完全根据项目的业务需要来定
 * 
 * @author superb
 *
 */
public class ThreadPoolUtil {
	
	private static ThreadPoolExecutor pool = null;

	/** 可缓存线程池 */
	private static ExecutorService cachedPool = null;
	
	/** 定长线程池 */
	private static ExecutorService fixedPool = null;
	
	/** 定长线程池，支持定时及周期性 */
	private static ScheduledExecutorService schedulPool = null;
	
	/** 单例线程池 */
	private static ExecutorService singlePool = null;
	
	
	private ThreadPoolUtil() {
	}
	
	/**
	 * 得到一个ThreadPoolExecutor线程池
	 * new ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, 
	 * 			long keepAliveTime, TimeUnit unit, BlockingQueue
    
    
     
      workQueue, 
	 * 			RejectedExecutionHandler handler)
	 * 
	 * @corePoolSize 线程池大小
	 * @maximumPoolSize 线程池最大值
	 * @keepAliveTime 线程保存的存活时间
	 * @workQueue 线程数超过线程大小时，任务存在这个队列中
	 * @handler 线程超过队列时，处理办法
	 * @return
	 */
	public static ThreadPoolExecutor newInstance(){
		if(pool==null){
			synchronized(ThreadPoolUtil.class){
				if(pool==null){
					pool = new ThreadPoolExecutor(3, 5, 10, TimeUnit.SECONDS,
							new ArrayBlockingQueue
     
     
      
      (10), new ThreadPoolExecutor.DiscardOldestPolicy());
				}
			}
		}
		return pool;
	}
	
	/**
	 * 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
	 * 
	 * 线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。 
	 * @return CachedThreadPool
	 */
	public static ExecutorService cachedInstance(){
		if(cachedPool == null){
			synchronized (ThreadPoolUtil.class) {
				if(cachedPool==null){
					cachedPool = Executors.newCachedThreadPool();
				}
			}
		}	
		return cachedPool;
	} 
	
	/**
	 * 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。(这里线程池大小为3)
	 * 
	 * 定长线程池的大小最好根据系统资源进行设置
	 * 
	 * @return CachedThreadPool
	 */
	public static ExecutorService fixedInstance(){
		if(fixedPool == null){
			synchronized (ThreadPoolUtil.class) {
				if(fixedPool==null){
					fixedPool = Executors.newFixedThreadPool(3);
				}
			}
		}	
		return fixedPool;
	} 
	
	/**
	 * 创建一个定长线程池，支持定时及周期性任务执行，（定时任务）
	 * 
	 * @return CachedThreadPool
	 */
	public static ScheduledExecutorService schedulInstance(){
		if(schedulPool == null){
			synchronized (ThreadPoolUtil.class) {
				if(schedulPool==null){
					schedulPool = Executors.newScheduledThreadPool(3);
				}
			}
		}	
		return schedulPool;
	} 
	
	/**
	 * 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
	 * 
	 * 顺序执行各个任务。
	 * @return CachedThreadPool
	 */
	public static ExecutorService singleInstance(){
		if(singlePool == null){
			synchronized (ThreadPoolUtil.class) {
				if(singlePool==null){
					singlePool = Executors.newScheduledThreadPool(10);
				}
			}
		}	
		return singlePool;
	} 
}
package com.superb.juint_thread;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 测试线程池的实现main类
 *
 */
public class ThreadMain {
    public static void main( String[] args ){
    	//singleMethod();
    	//cachedMethod();
    	//schedulMethod();
    	//fixedMethod();
    	threadPoolMethod();
    }
    
    /**
     * 描述：
     * 		得到一个ThreadPoolExecutor线程池，
     * 		通过new ThreadPoolExecutor()对象类来实现。
     * 		该方法new一个 （@corePoolSize） 线程池大小为 3 的线程池。
     * 		模拟任务有10个，每次执行三个，剩余的放在队列中等待执行
     * 
     * result:
     * ---------------BEGIN--------------
     * ---------------END--------------
     * -----------pool-1-thread-1---2016-08-12 05:47:13
     * -----------pool-1-thread-2---2016-08-12 05:47:13
     * -----------pool-1-thread-3---2016-08-12 05:47:13
     * 
     * -----------pool-1-thread-1---2016-08-12 05:47:15
     * -----------pool-1-thread-3---2016-08-12 05:47:15
     * -----------pool-1-thread-2---2016-08-12 05:47:15
     * 
     * -----------pool-1-thread-1---2016-08-12 05:47:17
     * -----------pool-1-thread-3---2016-08-12 05:47:17
     * -----------pool-1-thread-2---2016-08-12 05:47:17
     * 
     * -----------pool-1-thread-3---2016-08-12 05:47:19
     */
    public static void threadPoolMethod(){
    	ThreadPoolExecutor pool = ThreadPoolUtil.newInstance();
		System.out.println("---------------BEGIN--------------");
    	for(int i = 0; i < 10; i++){
    		pool.execute(new Runnable() {
    			public void run() {
    				System.out.println("-----------"+Thread.currentThread().getName()+
    						"---"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
    				try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
    			}
    		});
    	}
		System.out.println("---------------END--------------");
    }
    
    /**
     * 描述：
     * 		定时器，可以指定业务每隔指定时间执行一次，该方法中每隔 3 秒模拟一次业务处理
     * result:
     * 
     * 模拟业务处理=====2016-08-12 04:30:37
	 * 模拟业务处理=====2016-08-12 04:30:40
	 * 模拟业务处理=====2016-08-12 04:30:43
	 * 模拟业务处理=====2016-08-12 04:30:46
	 * 模拟业务处理=====2016-08-12 04:30:49
     */
    public static void schedulMethod(){
    	ScheduledExecutorService pool = ThreadPoolUtil.schedulInstance();
    	pool.scheduleAtFixedRate(new Runnable() {
			public void run() {
				System.out.println("模拟业务处理====="+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss")
						.format(new Date()));
			}
		}, 0, 3, TimeUnit.SECONDS);
    }
    
    /**
     * 描述：
     * 		线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
	 * 结论：
	 * 		当每个任务执行5s时，任务间隔为2s时，上一个任务未执行完时，下一个任务已经开始，此时不会复用上一个线程。
	 * 		当任务执行为2s，任务间隔为5s时，下一个任务开始时，上一个任务已完成，此时会复用上一个线程
	 *  result 1:
	 *  
     
     
	 *	
     
     
------>pool-1-thread-1<------

	 *	
     
     
------>pool-1-thread-2<------

	 *	
     
     
------>pool-1-thread-3<------

	 *	
     
     
------>pool-1-thread-1<------

	 *	
     
     
------>pool-1-thread-2<------

	 *	
     
     
------>pool-1-thread-3<------

	 *	
     
     
----------->SUCCESS<------

	 *
	 * 	result 2:
	 *  
     
     
----------->BEGIN<-------

	 *	
     
     
------>pool-1-thread-1<------

	 *	
     
     
------>pool-1-thread-1<------

	 *	
     
     
------>pool-1-thread-1<------

	 *	
     
     
------>pool-1-thread-1<------

	 *	
     
     
----------->SUCCESS<------

	 */
	public static void cachedMethod() {
    	ExecutorService pool = ThreadPoolUtil.cachedInstance();
		System.out.println("
     
     
----------->BEGIN<-------
");
		for (int i = 0; i < 10; i++) {
			pool.execute(new Runnable() {
				public void run() {
					System.out.println("
     
     
------>" + Thread.currentThread().getName() + "<------
");
					try {
						Thread.sleep(5000);// 每个任务执行5s,
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
			try {
				Thread.sleep(2000);// 每个任务间隔2s
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		System.out.println("
     
     
----------->SUCCESS<------
");
    }

	/**
	 * 描述：
	 * 		定长线程池，可控制线程最大并发数，超出的线程会在队列中等待，
	 * 		该方法中我们实行了一个长度为3的线程池，其中开启10个任务，每次只执行3个任务，
	 * 		剩余任务会在队列中等待，直到有线程空闲执行下一个任务
	 * result:
	 * ---------------BEGIN--------------
	 * ---------------END--------------
	 * ----模拟任务----pool-1-thread-2----2016-08-12 05:09:02
	 * ----模拟任务----pool-1-thread-1----2016-08-12 05:09:02
	 * ----模拟任务----pool-1-thread-3----2016-08-12 05:09:02
	 * 
	 * ----模拟任务----pool-1-thread-3----2016-08-12 05:09:07
	 * ----模拟任务----pool-1-thread-2----2016-08-12 05:09:07
	 * ----模拟任务----pool-1-thread-1----2016-08-12 05:09:07
	 * 
	 * ----模拟任务----pool-1-thread-3----2016-08-12 05:09:12
	 * ----模拟任务----pool-1-thread-2----2016-08-12 05:09:12
	 * ----模拟任务----pool-1-thread-1----2016-08-12 05:09:12
	 * 
	 * ----模拟任务----pool-1-thread-3----2016-08-12 05:09:17
	 * 
	 */
	public static void fixedMethod() {
		ExecutorService pool = ThreadPoolUtil.fixedInstance();
		System.out.println("---------------BEGIN--------------");
		for (int i = 0; i < 10; i++) {
			pool.execute(new Runnable() {
				
				public void run() {
					System.out.println("----模拟任务----"+Thread.currentThread().getName()
							+ "----"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
					try {
						Thread.sleep(5000);//模拟每隔线程执行5s
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
		System.out.println("---------------END--------------");
	}


	/**
	 * 描述：
	 * 		结果依次输出，相当于顺序执行各个任务
	 * result:
	 * ---------------BEGIN--------------
	 * 当前执行任务index值为：1
	 * 当前执行任务index值为：2
	 * 当前执行任务index值为：3
	 * 当前执行任务index值为：4
	 * 当前执行任务index值为：5
	 * 当前执行任务index值为：6
	 * 当前执行任务index值为：7
	 * 当前执行任务index值为：8
	 * 当前执行任务index值为：9
	 * ---------------END--------------
	 */
	public static void singleMethod() {
		ExecutorService pool = ThreadPoolUtil.singleInstance();
		System.out.println("---------------BEGIN--------------");
		for (int i = 1; i < 10; i++) {
			final  int index = i;
			pool.execute(new Runnable() {
				public void run() {
					System.out.println("当前执行任务index值为："+index);
				}
			});
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("---------------END--------------");
	}
}

    
    
----------->BEGIN<-------


变形记-四爷
关注
专栏目录
关于线程池的五种实现方式，七大参数，四种拒绝策略
lonely_bin的博客
08-08 1347
1 池化技术之线程池 什么是池化技术？简单来说就是优化资源的使用，我准备好了一些资源，有人要用就到我这里拿，用完了就还给我。而一个比较重要的的实现就是线程池。那么线程池用到了池化技术有什么好处呢？ 降低资源的消耗 提高响应的速度 方便管理 也就是 线程复用、可以控制最大并发数、管理线程 2 线程池的五种实现方式 其实线程池我更愿意说成四种封装实现方式，一种原始实现方式。这四种封装的实现方式都是依赖于最原始的的实现方式。所以这里我们先介绍四种封装的实现方式 2.1 newSingleThreadExecu
Java多线程与并行计算：深入剖析Java线程，线程池，以及利用Java进行并行计算的策略
哎 你看的博客
05-28 1173
一、Java线程概述 线程基础概念 Java线程创建和启动 线程的生命周期及其状态转换 线程中断 线程优先级 二、线程同步 锁的概念 synchronized关键字 volatile关键字 ThreadLocal变量 三、Java线程通信 wait()、notify()和notifyAll()方法 join()方法 管道输入/输出流 通过Lock和Condition实现线程同步 四、Java线程池 线程池的概念和原理 Java Executors提供的各种线程池 自定义线程池 线程池的监控 五、并行计算
java基础：简单实现线程池
weixin_30258901的博客
06-19 178
前段时间自己研究了下线程池的实现原理，通过一些源码对比，发现其实核心的东西不难，于是抽丝剥茧，决定自己实现一个简单线程池，当自已实现了出一个线程池后。发现原来那么高大上的东西也可以这么简单。 先上原理图：为了更好的在手机上显示，我重新把图画了一遍 上代码之前，要先补充一下线程池构造的核心几个点 线程池里的核心线程数与最大线程数 线程池里真正工作的线程worker 线程池里用来存取任务的队列...
线程池的实现
最新发布
weixin_53903743的博客
09-23 1262
如果isPoolRuning_为ture，但是在cached模式下，根据当前时间和上一次线程使用时间，判断有没有超过60s，如果超过了，并且当前线程数大于初始定义，说明不需要那么多线程了就需要回收线程资源；cached模式下，需要根据任务数量和空闲线程的数量，判断是否需要创建新的线程出来，如果任务数大于现有的空闲线程数并且没有超过阙值，就增加线程，修改相关数量；创建线程对象，把线程函数threadFunc给到thread线程对象，使用绑定器，获取线程id，方便回收线程资源；
Java基础-线程名字的定义和获取
二丫的博客
09-25 407
线程名字的获取和定义 public class Demo { //线程名字的获取和定义 public static void main(String[] args) { MyTread myTread = new MyTread("张三"); MyTread myTread1 = new MyTread("李四"); Thread.currentThread().setName("王麻子");//将主线程的名字修改成王麻子
JAVA常用的几种线程池
白丝巾的博客
01-17 406
JAVA常用的几种线程池 1、newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 这种类型的线程池特点是： 工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。 如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(
java中线程池的几种实现方式
热门推荐
w2393040183的专栏
08-11 2万+
1、线程池简介：     多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。         假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。     如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。                 一个线程
Java中常用线程池
12-16
Java中常用的线程池有以下几种： 1. FixedThreadPool：该线程池大小固定，不会改变，适用于负载比较重的服务器。 ```java ExecutorService executor = Executors.newFixedThreadPool(10); ``` 2. CachedThreadPool：...
解析Java中常用的阻塞队列实现：ArrayBlockingQueue
阻塞队列是Java多线程编程中常用的一种数据结构，它具备先进先出（FIFO）的特性。与普通的队列相比，阻塞队列在队列为空时会阻塞获取操作，直到队列中有新的元素被插入；在队列已满时会阻塞插入操作，直到队列中有...
util-java:项目中常使用的工具收集
05-13
在Java开发过程中，工具类库的使用至关重要，它们可以极大地提高开发效率，简化代码，确保程序的健壮性。"util-java"是一个专门收集并整合了常见工具方法的项目，旨在为开发者提供便利。这个项目包含了两个主要模块...
java线程池分析.pdf
02-16
查看jdk1.8，简要分析java中常用线程池的几个对象，包括一些基本方法的使用，jdk8中新增的方法，线程池这块的内容比较多，人力有时尽，后续慢慢的分析，提升自身的同时也把所学分享。 熬夜赶出，各位给个小星星
Java 实现简单的线程池
11-11
用java实现的线程池，自己是初学着，程序参考网上。
Java多线程实现-线程池
kking_edc的博客
08-28 1538
在《阿里巴巴Java手册》里有这样一条： 【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 说明：使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。 简单来说使用线程池有以下几个目的： 线程是稀缺资源，不能频繁的创建 解耦作用：线程创建时执行完全分开，方便维护 可以将其放入一个池子中，方便给其他任务进行复用 一、线程池原理 谈到线程池就会想到池化技术，其中最
线程池的四种实现
qq_40921842的博客
07-09 1135
一.四种常见的线程池详解 线程池的返回值ExecutorService简介： ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程 具体的4种常用的线程池实现如下：（返回值都是ExecutorService） 2.1 Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务 示例代码：
Java线程池的4种实现
zengjyxxz的博客
05-31 907
线程池都继承了ExecutorService的接口，所以他们都具有ExecutorService的生命周期方法：运行，关闭，终止； 因为继承了ExecutorService接口，所以它在被创建的时候就是处于运行状态，当线程没有任务执行时，就会进入关闭状态，只有调用了shutdown（）的时候才是正式的终止了这个线程池。 Java通过Executors工厂类提供我们的线程池一共有4种： ThreadPoolExecutor //指定线程数的线程池。 newFixedThreadPool(); //启动固定线程
字节跳动高工面试：Spring容器如何解决循环依赖的原理，成功拿到offer
m0_53537576的博客
03-17 405
前言 “金九银十”的秋招热潮已经开始了，经过7月8月这两个月的提前批，终于成功拿下了一些大厂的offer。小编经过这么多次的面试，这两天整理了一份面试清单分享给大家，希望能给大家一点帮助(java方向)，觉得有帮助的同学可以转发点个赞哦~~ 二、我们先来看看这份笔记到底有什么 1、先把kubernetes跑起来（先跑起来+创建kubernetes集群+部署应用+访问应用+Scale应用+滚动更新） 2、重要概念 3、部署kubernetes Cluster（安装docker+安装 kubelet.ku
Java 常用线程池
王欧的博客
05-21 140
Java 常用线程池 1.Executor、ExecutorService、ScheduledExecutorService、ScheduledThreadPoolExecutor、ThreadPoolExecutor、Executors的关系 关系说明： ​ 1. Executor是顶级接口，但是它只是执行线程的工具而不是线程池，定义了一个无返回值的execute方法; ​ 2. ExecutorService接口继承了Executor，是真正的线程池接口 ​ 3. Sc
JAVA 常用线程池
joynet007的专栏
03-13 272
JAVA 固定线程池 FixedThreadPool 线程池介绍 Java通过Executors提供四种线程池： newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 ...
Java常用的线程池
乐嘉工作室
03-28 367
CachedThreadPool：该线程池会创建一个可缓存的线程池，线程池中的线程数会根据需要自动增加或减少。如果线程池中的线程闲置时间过长，线程池中的线程会被回收。WorkStealingPool：该线程池会根据需要自动增加或减少线程，线程池中的线程会自动获取新的任务执行，可以提高CPU利用率。FixedThreadPool：该线程池会创建指定数量的线程，这些线程会一直存在，直到线程池被关闭。这些线程池在不同场景下有不同的适用性，开发人员可以根据实际情况选择适合自己的线程池来管理线程。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值