`

Java线程池学习笔记二

    博客分类:
  • Java
 
阅读更多

一、背景       

       在Java线程池学习笔记一中,理解了几个常用的常用的线程池创建的静态工程方法。本篇就Java线程池中的核心:ThreadPoolExecutor,作深入的学习。

 

二、ThreadPoolExecutor的详细分析

       ThreadPoolExecutor是java.util.concurrent包中一个类,它实现了Executor和ExecutorService两个接口,继承了AbstractExecutorService,也是ScheduledThreadPoolExecutor的直接父类。ThreadPoolExecutor的构造函数有以下四个:

       1、ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,   BlockingQueue<Runnable> workQueue) :用给定的初始参数和默认的线程工厂及被拒绝的执行处理程序创建新的 ThreadPoolExecutor。

 

       2、ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler):用给定的初始参数和默认的线程工厂创建新的 ThreadPoolExecutor。      

       3、ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory):用给定的初始参数和默认被拒绝的执行处理程序创建新的 ThreadPoolExecutor。    

       4、ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler):用给定的初始参数创建新的 ThreadPoolExecutor。

       这四个构造函数的参数的含义如下:

       corePoolSize:表示池中所保存的线程数(包括空闲线程)

       maximumPoolSize:池中允许的最大线程数

       keepAliveTime:当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间

       unit:keepAliveTime 参数的时间单位

       workQueue:执行前用于保持任务的队列,此队列仅保持由 execute方法提交的 Runnable任务

       handler:由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序

       threadFactory:执行程序创建新线程时使用的工厂

       在JDK1.7的API中,关于ThreadPoolExecutor的使用有着一样一个说明:强烈建议程序员使用较为方便的 Executors 工厂方法 Executors.newCachedThreadPool()(无界线程池,可以进行自动线程回收)、Executors.newFixedThreadPool(int)(固定大小线程池)和 Executors.newSingleThreadExecutor()(单个后台线程),它们均为大多数使用场景预定义了设置。

       如果需要自己手动配置和调整此类,则可以根据以下说明作为指导:

       1、核心和最大池大小

       ThreadPoolExecutor 将根据 corePoolSize(参见 getCorePoolSize())和 maximumPoolSize(参见 getMaximumPoolSize())设置的边界自动调整池大小。当新任务在方法 execute(java.lang.Runnable) 中提交时,如果运行的线程少于 corePoolSize,则创建新线程来处理请求,即使其他辅助线程是空闲的。如果运行的线程多于 corePoolSize 而少于 maximumPoolSize,则仅当队列满时才创建新线程。如果设置的 corePoolSize 和 maximumPoolSize 相同,则创建了固定大小的线程池。如果将 maximumPoolSize 设置为基本的无界值(如 Integer.MAX_VALUE),则允许池适应任意数量的并发任务。在大多数情况下,核心和最大池大小仅基于构造来设置,不过也可以使用 setCorePoolSize(int) 和 setMaximumPoolSize(int) 进行动态更改。

        2、按需构造

        默认情况下,即使核心线程最初只是在新任务到达时才创建和启动的,也可以使用方法 prestartCoreThread() 或 prestartAllCoreThreads() 对其进行动态重写。如果构造带有非空队列的池,则可能希望预先启动线程。

        3、创建新线程

        使用 ThreadFactory 创建新线程。如果没有另外说明,则在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程,并且这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。通过提供不同的 ThreadFactory,可以改变线程的名称、线程组、优先级、守护进程状态,等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程,则执行程序将继续运行,但不能执行任何任务。

        4、保持活动时间

        如果池中当前有多于 corePoolSize 的线程,则这些多出的线程在空闲时间超过 keepAliveTime 时将会终止(参见 getKeepAliveTime(java.util.concurrent.TimeUnit))。这提供了当池处于非活动状态时减少资源消耗的方法。如果池后来变得更为活动,则可以创建新的线程。也可以使用方法 setKeepAliveTime(long, java.util.concurrent.TimeUnit) 动态地更改此参数。使用 Long.MAX_VALUE TimeUnit.NANOSECONDS 的值在关闭前有效地从以前的终止状态禁用空闲线程。默认情况下,保持活动策略只在有多于 corePoolSizeThreads 的线程时应用。但是只要 keepAliveTime 值非 0,allowCoreThreadTimeOut(boolean) 方法也可将此超时策略应用于核心线程。

       5、排队

       所有 BlockingQueue都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互:

       如果运行的线程少于 corePoolSize,则Executor始终首选添加新的线程,而不进行排队。

       如果运行的线程等于或多于corePoolSize,则Executor始终首选将请求加入队列,而不添加新的线程。

       如果无法将请求加入队列,则创建新的线程,除非创建此线程超出maximumPoolSize,在这种情况下,任务将被拒绝。

       排队有三种通用策略:

       a.直接提交。工作队列的默认选项是 SynchronousQueue,它将任务直接提交给线程而不保持它们。在此,如果不存在可用于立即运行任务的线程,则试图把任务加入队列将失败,因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。

       b.无界队列。使用无界队列(例如,不具有预定义容量的 LinkedBlockingQueue)将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样,创建的线程就不会超过 corePoolSize。(因此,maximumPoolSize 的值也就无效了。)当每个任务完全独立于其他任务,即任务执行互不影响时,适合于使用无界队列;例如,在 Web 页服务器中。这种排队可用于处理瞬态突发请求,当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。

       c.有界队列。当使用有限的 maximumPoolSizes 时,有界队列(如 ArrayBlockingQueue)有助于防止资源耗尽,但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷:使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销,但是可能导致人工降低吞吐量。如果任务频繁阻塞(例如,如果它们是 I/O 边界),则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小,CPU 使用率较高,但是可能遇到不可接受的调度开销,这样也会降低吞吐量。

       6、被拒绝的任务

       当Executor已经关闭,并且Executor将有限边界用于最大线程和工作队列容量,且已经饱和时,在方法execute(java.lang.Runnable) 中提交的新任务将被拒绝。在以上两种情况下, execute方法都将调用其RejectedExecutionHandler的RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor)方法。在API中提供了四种预定义的处理程序的策略:在默认的ThreadPoolExecutor.AbortPolicy中,处理程序遭到拒绝将抛出运行时RejectedExecutionException;在ThreadPoolExecutor.CallerRunsPolicy中,线程调用运行该任务的execute本身(此策略提供简单的反馈控制机制,能够减缓新任务的提交速度);在ThreadPoolExecutor.DiscardPolicy中,不能执行的任务将被删除;在ThreadPoolExecutor.DiscardOldestPolicy中,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,然后重试执行程序(如果再次失败,则重复此过程)。

       定义和使用其他种类的RejectedExecutionHandler类也是可能的,但这样做需要非常小心,尤其是当策略仅用于特定容量或排队策略时。

       7、钩子(hook)方法

       此类提供protected可重写的beforeExecute(java.lang.Thread, java.lang.Runnable)和afterExecute(java.lang.Runnable, java.lang.Throwable)方法,这两种方法分别在执行每个任务之前和之后调用。它们可用于操纵执行环境;例如,重新初始化ThreadLocal、搜集统计信息或添加日志条目。此外,还可以重写方法terminated()来执行Executor完全终止后需要完成的所有特殊处理。如果钩子(hook)或回调方法抛出异常,则内部辅助线程将依次失败并突然终止。

       8、队列维护

       方法getQueue()允许出于监控和调试目的而访问工作队列。强烈反对出于其他任何目的而使用此方法。remove(java.lang.Runnable)和purge()这两种方法可用于在取消大量已排队任务时帮助进行存储回收。

       9、终止

       程序不再引用的池没有剩余线程会自动shutdown。如果希望确保回收取消引用的池(即使用户忘记调用shutdown()),则必须安排未使用的线程最终终止:设置适当保持活动时间,使用0核心线程的下边界和/或设置allowCoreThreadTimeOut(boolean)。

 

三、实例展示

      ThreadPoolExecutor可以被很多类进行扩展,下面通过一个实例说明:

      

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 重写一个或多个受保护的钩子 (hook)方法,实现简单的暂停/恢复功能
 */
public class PausableThreadPoolExecutor extends ThreadPoolExecutor {
	private boolean isPaused;
	private ReentrantLock pauseLock = new ReentrantLock();
	private Condition unpaused = pauseLock.newCondition();
	
	private int corePoolSize ;
	private int maximumPoolSize ;
	private long keepAliveTime ;
	private TimeUnit unit;
	private BlockingQueue<Runnable> workQueue;
	private RejectedExecutionHandler handler;

	public PausableThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) { 
	   super(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,handler);
	   this.corePoolSize = corePoolSize ;
	   this.maximumPoolSize = maximumPoolSize;
	   this.keepAliveTime = keepAliveTime ;
	   this.unit = unit ;
	   this.workQueue = workQueue ;
	   this.handler = handler ;
	}
	
	public int getCorePoolSize(){
		return corePoolSize ;
	}
	 
	public boolean isPaused() {
		return isPaused;
	}

	public ReentrantLock getPauseLock() {
		return pauseLock;
	}

	public Condition getUnpaused() {
		return unpaused;
	}

	public int getMaximumPoolSize() {
		return maximumPoolSize;
	}

	public long getKeepAliveTime() {
		return keepAliveTime;
	}

	public TimeUnit getUnit() {
		return unit;
	}

	public BlockingQueue<Runnable> getWorkQueue() {
		return workQueue;
	}

	public RejectedExecutionHandler getHandler() {
		return handler;
	}

	protected void beforeExecute(Thread t, Runnable r) {
	   super.beforeExecute(t, r);
	   pauseLock.lock();
	   try{
	      while (isPaused) unpaused.await();
	   }catch(InterruptedException ie) {
	      t.interrupt();
	   }finally {
	      pauseLock.unlock();
	   }
	}
	 
	public void pause() {
	   pauseLock.lock();
	   try{
	      isPaused = true;
	      System.out.println("pause....");
	   }finally{
	      pauseLock.unlock();
	   }
	}
	 
	public void resume() {
	   pauseLock.lock();
	   try{
	      isPaused = false;
	      unpaused.signalAll();
	      System.out.println("resume....");
	   }finally {
	      pauseLock.unlock();
	   }
	 }
}

 

四、小结

      上面的实例只是通过扩展ThreadPoolExecutor类来自己配置线程池的一种方式,在这里强烈建议遵循JDK的说明,毕竟在软件开发这一行业,不需要重复造车。

分享到:
评论

相关推荐

    Java分布式应用学习笔记07线程池应用

    Java分布式应用学习笔记07线程池应用

    java线程池概念.txt

    当然,现在用过的东西并不是代表以后还能娴熟的使用,做好笔记非常重要; 1:必须明白为什么要使用线程池:(这点很重要)  a:手上项目所需,因为项目主要的目的是实现多线程的数据推送;需要创建多线程的话,那...

    JAVA并发编程实践-线程池-学习笔记

    当调用 start 启动线程时 Java 虚拟机会调 用该类的 run方法。 那么该类的 run() 方法中就是调用了 Runnable 对象的 run() 方法。 我 们可以继承重写Thread 类,在其 start 方法中添加不断循环调用传递过来的 ...

    Java 并发学习笔记:进程和线程,并发理论,并发关键字,Lock 体系,原子操作类,发容器 &amp; 并发工具,线程池,并发实践

    Java 并发学习笔记: 进程和线程, 并发理论, 并发关键字, Lock 体系, 原子操作类, 发容器 & 并发工具, 线程池, 并发实践 Java是一种面向对象的编程语言,由Sun Microsystems于1995年推出。它是一种跨平台的...

    基于Java线程池技术实现Knock Knock游戏项目.zip

    学习笔记:整理了Java语言在游戏开发中的核心知识点和常用技术,方便你随时查阅和学习。 适用人群: 这份资源包适用于所有对Java游戏开发感兴趣的朋友,无论你是计算机专业的学生,还是希望业余时间尝试游戏开发的...

    java多线程学习笔记之自定义线程池

    本篇文章主要介绍了java多线程学习笔记之自定义线程池 ,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

    java内部学习笔记.docx

    Java技术基础 4 1.1编程语言 4 1.2 Java的特点 4 1.3 Java开发环境 4 1.4 Java开发环境配置 5 1.5 Linux命令与相关知识 5 1.6 Eclipse/Myeclipse程序结构 6 Java语言基础 7 ...5.14线程池 67 5.15双缓冲队列 68

    Java并发编程学习笔记

    2、可重入锁与 Synchronized 的其他特性 3、ThreadLocal 的底层实现与使用 4、ReentrantLock底层实现和如何使用 5、Condition源码分析 6、ReentrantReadWriteLock底层实现原理 7、并发工具类CountDownLatch 、...

    JAVA课程学习笔记.doc

    线程池框架2 第一层结构2 接口简介3 核心实现类3 辅助类4 完成服务4 源码原理解析4 线程池执行原理4 调度线程池原理7 异步结果源码分析10

    java 线程总结笔记

    花费了一上午的时候 写了一些demo。认识到四种线程池的区别。上传到csdn 供以后学习

    Java-note:Java学习笔记

    Java-noteJava学习笔记java相关Java基础Java集合JVMJava并发线程池Java网络计算机基础数据库计算机网络操作系统面向对象思想面向对象设计模式Java WebSpringSpringBoot

    线程安全、volatile关键字、原子性、并发包、死锁、线程池.md

    线程安全、volatile关键字、原子性、并发包、死锁、线程池学习笔记

    学习笔记:多线程Java Socket编程示例

    其中采用Java 的ExecutorService来进行线程池的方式实现多线程,模拟客户端多用户向同一服务器端发送请求....注意,此为学习笔记,可以作为参考学习使用,不建议商业使用或生产使用。 废话不多说,直接上代码。

    Java并发编程(学习笔记).xmind

    (1)二值信号量可用作互斥体(mutex) (2)实现资源池,例如数据库连接池 (3)使用信号量将任何一种容器变成有界阻塞容器 栅栏 能够阻塞一组线程直到某个事件发生 栅栏和闭锁的...

    notes-learning-java-concurrency:java 并发学习笔记

    Java并发编程学习笔记 这是我两年前(2012-05)的学习笔记。。 -- 本文不会详细介绍java5以前的多线程开发的知识,而是重点介绍java5以来多线程开发的一些新变化。部分文字、代码都是摘抄、提炼过来的,大家有兴趣可...

    高级java笔试题-ShiftJava:学到头秃的Java的小笔记

    入坑笔记,劝退一波,别搞后端了,转算法去吧! Java 设计模式 算法 网络 操作系统 数据库 Spring 分布式 大数据 目录 Java 1. 基础 基础:数据与程序结构、关键字等。 对象与类:继承、接口、抽象类、内部类、枚举...

    Java – 并发编程 – 线程池

    做的学习笔记,并加入了自己的理解,谢谢 使用线程池的原因 我们创建的线程在运行结束后都会被虚拟机销毁,如果线程数量多的话,频繁的创建和销毁线程会大大浪费时间和效率,更重要的是浪费内存,线程池可以让线程...

    水木清华站∶Java版精华区 含jsp及js等集合.chm

    [目录]Java学习笔记(推荐) 6. [目录]JDBC文档 7. [目录]RMI 文档 2. [目录]Java资源(文档-书籍-下载-注册码) 1. [目录]License 和注册码 2. [目录]好书推荐 3. [目录]关于Java的...

    996视频学习笔记-20211115.docx

    1 适合初级进阶 2 简单的总结记录 3 涵盖 java8新特性lambda,Stream API,Try-with-resource,Guava,线程池,Loombok,验证框架

Global site tag (gtag.js) - Google Analytics