`
lastsoul
  • 浏览: 34526 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

jdk1.5线程池

 
阅读更多
一、API研究

线程池类为 java.util.concurrent.ThreadPoolExecutor,常用构造方法为:
ThreadPoolExecutor(int corePoolSize,   
                   int maximumPoolSize,   
                   long keepAliveTime, TimeUnit unit,   
                   BlockingQueue<Runnable> workQueue,   
                   RejectedExecutionHandler handler)  


•corePoolSize
线程池维护线程的最少数量
•maximumPoolSiz
线程池维护线程的最大数量
•keepAliveTime
线程池维护线程所允许的空闲时间
•unit
线程池维护线程所允许的空闲时间的单位
•workQueue
线程池所使用的缓冲队列
•handler
线程池对拒绝任务的处理策略

一个任务通过 execute(Runnable)方法被添加到线程池,任务就是一个 Runnable类型的对象,任务的执行方法就是 Runnable类型对象的run()方法。

看这个参数很容易让人以为是线程池里保持corePoolSize个线程,如果不够用,就加线程入池直至maximumPoolSize大小,如果还不够就往workQueue里加,如果workQueue也不够就用RejectedExecutionHandler来做拒绝处理。

但实际情况不是这样,具体流程如下:

1)当池子大小小于corePoolSize就新建线程,并处理请求

2)当池子大小等于corePoolSize,把请求放入workQueue中,池子里的空闲线程就去从workQueue中取任务并处理

3)当workQueue放不下新入的任务时,新建线程入池,并处理请求,如果池子大小撑到了maximumPoolSize就用RejectedExecutionHandler来做拒绝处理

4)另外,当池子的线程数大于corePoolSize的时候,多余的线程会等待keepAliveTime长的时间,如果无请求可处理就自行销毁

当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性:
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue我常用的是:java.util.concurrent.ArrayBlockingQueue

handler有四个选择: •ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
•ThreadPoolExecutor.CallerRunsPolicy()
由调用者执行这个任务
•ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
•ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务

java.util.concurrent.Executors工具类还提供了以下几个连接池:

a.       static ExecutorService newCachedThreadPool()

产生一个ExecutorService对象,这个对象带有一个线程池,线程池的大小会根据需要调整,线程执行完任务后返回线程池,供执行下一次任务使用
比较适合没有固定大小并且比较快速就能完成的小任务。

b.       static ExecutorService newFixedThreadPool(int poolSize)

产生一个ExecutorService对象,这个对象带有一个大小为poolSize的线程池,若任务数量大于poolSize,任务会被放在一个queue里顺序执行

c.       static ExecutorService newSingleThreadExecutor()

产生一个ExecutorService对象,这个对象只有一个线程可用来执行任务,若任务多于一个,任务将按先后顺序执行。
d. static ScheduledExecutorServicenewSingleThreadScheduledExecutor()
创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
e. static ScheduledExecutorServicenewSingleThreadScheduledExecutor():创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
f.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) :用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。

二,示例解析
package cn.gaialine.threadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
import java.util.concurrent.TimeUnit;

/**
 * 线程池测试用例
 * @author yangyong
 *
 */
public class TestThreadPool {
	//线程池维护线程的最少数量
	private static final int COREPOOLSIZE = 2;
	//线程池维护线程的最大数量
	private static final int MAXINUMPOOLSIZE = 5;
	//线程池维护线程所允许的空闲时间
	private static final long KEEPALIVETIME = 4;
	//线程池维护线程所允许的空闲时间的单位
	private static final TimeUnit UNIT = TimeUnit.SECONDS;
	//线程池所使用的缓冲队列,这里队列大小为3
	private static final BlockingQueue<Runnable> WORKQUEUE = new ArrayBlockingQueue<Runnable>(3);
	//线程池对拒绝任务的处理策略:AbortPolicy为抛出异常;CallerRunsPolicy为重试添加当前的任务,他会自动重复调用execute()方法;DiscardOldestPolicy为抛弃旧的任务,DiscardPolicy为抛弃当前的任务
	private static final AbortPolicy HANDLER = new ThreadPoolExecutor.AbortPolicy();

	public static void main(String[] args) {
		// TODO 初始化线程池
		ThreadPoolExecutor threadPool = new ThreadPoolExecutor(COREPOOLSIZE, MAXINUMPOOLSIZE, KEEPALIVETIME, UNIT, WORKQUEUE, HANDLER);
		for (int i = 1; i < 11; i++) {
			String task = "task@"+i;
			System.out.println("put->"+task);
			//一个任务通过 execute(Runnable)方法被添加到线程池,任务就是一个 Runnable类型的对象,任务的执行方法就是 Runnable类型对象的run()方法
			
			threadPool.execute(new ThreadPoolTask(task));
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		threadPool.shutdown();//关闭主线程,但线程池会继续运行,直到所有任务执行完才会停止。若不调用该方法线程池会一直保持下去,以便随时添加新的任务
	}
}


package cn.gaialine.threadpool;

import java.io.Serializable;

/**
 * 任务task
 * @author yangyong
 *
 */
public class ThreadPoolTask implements Runnable,Serializable{
	private static final long serialVersionUID = -8568367025140842876L;

	private Object threadPoolTaskData;
	private static int produceTaskSleepTime = 10000;
	
	public ThreadPoolTask(Object threadPoolTaskData) {
		super();
		this.threadPoolTaskData = threadPoolTaskData;
	}

	public void run() {
		// TODO Auto-generated method stub
		System.out.println("start..."+threadPoolTaskData);
		try {
			//模拟线程正在执行任务
			Thread.sleep(produceTaskSleepTime);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("stop..."+threadPoolTaskData);
		threadPoolTaskData = null;
	}
	
	public Object getTask(){
		return this.threadPoolTaskData;
	}
}


执行测试,每1秒添加一个任务,每个任务执行10秒,查看打印数据

put->task@1
start...task@1
put->task@2
start...task@2
put->task@3
put->task@4
put->task@5
put->task@6
start...task@6
put->task@7
start...task@7
put->task@8
start...task@8
put->task@9
Exception in thread "main" java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1760)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:767)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:658)
	at base.TestThreadPool.main(TestThreadPool.java:42)
stop...task@1
start...task@3
stop...task@2
start...task@4
stop...task@6
start...task@5
stop...task@7
stop...task@8
stop...task@3
stop...task@4
stop...task@5



从中可以看出task1和task2依次最先执行,这时候currentPoolSize=2达到了corePoolSize,task3、task4、task5被送入缓冲队列,达到了workQueue最大值3,task6、task7、task8开启新的线程开始执行,此时currentPoolSize=5达到了maximumPoolSize,task9、task10根据AbortPolicy策略抛出异常,不再执行task9和task10。10秒钟后task1、task2....依次执行完毕释放线程,开始执行队列里的task3、task4、task5,最后task3、4、5执行完毕,所有任务完成
分享到:
评论

相关推荐

    JDK1.5线程池源码及详细注释

    JDK 1.5引入了java.util.concurrent包,其中包含了线程池的实现,使得并发编程更加便捷和高效。线程池的核心在于它的设计策略,包括核心线程数、最大线程数、线程存活时间、工作队列以及拒绝策略。 线程池的主要类...

    jdk1.5线程池讲解

    JDK1.5的线程池讲解,示例代码,很精辟~

    JDK1.5中的线程池

    JDK1.5中的线程池(ThreadPoolExecutor)使用简介

    jdk1.5 windows 64位官方正式版,绝对有效

    对于并发编程,JDK1.5引入了java.util.concurrent包,其中包括了线程池、Future、Callable接口以及CyclicBarrier和Semaphore等同步工具类,极大地丰富了并发处理能力,提升了多线程环境下的性能和可维护性。...

    JDK1.5线程池

    资源很不错

    jdk jdk1.5 windows系统

    JDK1.5,也被称为Java SE 5.0,是Oracle公司于2004年发布的一个重大更新,带来了许多重要的新特性、改进和优化。以下是对这个版本的一些关键知识点的详细解释: 1. **泛型(Generics)**:JDK1.5引入了泛型,使得...

    jdk1.5+线程池应用

    使用jdk1.5 实现的线程池. 可以定制人物和其它特性. 下载后可以自己进行相关功能完善. 欢迎加QQ:934547801一起讨论

    jdk1.5 64位 免安装

    在并发处理上,JDK1.5引入了并发工具类(java.util.concurrent),包括线程池(ExecutorService)、并发容器(如ConcurrentHashMap)以及Future接口等,这些工具极大地提高了多线程环境下的程序设计效率和性能。...

    jdk1.5 for windows32 安装包

    安装程序"jdk1.5 for windows(32位)安装程序.exe"将引导用户完成配置步骤,包括选择安装目录、设置环境变量(如JAVA_HOME、PATH和CLASSPATH)以及选择是否创建桌面快捷方式。 请注意,由于JDK 1.5已经过时,可能...

    JDK1.5免安装

    **JDK1.5免安装详解** Java Development Kit(JDK)是Oracle公司提供的用于开发和运行Java应用程序的工具集合。JDK1.5,也称为Java 5.0,是一个重要的版本,它引入了许多创新特性,提升了Java编程的效率和性能。...

    jdk1.5 and tomcat5.5

    标题"jdk1.5 and tomcat5.5"指的是Java Development Kit (JDK) 1.5版本与Apache Tomcat 5.5版本的组合。这两个组件是开发和运行Java应用程序的关键工具,特别是对于Web应用程序。 描述中提到的"jdk-1_5_0_22-...

    jdk1.5 64位

    JDK 1.5的内存模型和并发工具也得到了增强,添加了如`java.util.concurrent`包,其中包含了线程池、同步容器、并发队列等高效并发编程工具,极大地提升了多线程环境下应用程序的性能和可维护性。 至于文件列表中的`...

    jdk1.5.0.22 64位

    **Java Development Kit (JDK) 1.5.0.22 64位详解** JDK(Java Development Kit)是Oracle公司发布的用于开发、编译、调试Java应用程序的工具集合。版本1.5.0.22是JDK的一个历史版本,也被称为Java 5.0 Update 22,...

    jdk1.5安装包

    JDK 1.5是Java历史上的一个重要版本,发布于2004年,正式名称为Java SE 5.0(Java Standard Edition 5.0)。这个版本引入了许多新特性,对Java语言进行了重大改进,极大地提升了开发效率和代码质量。 1. **泛型...

    JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用简介.doc

    JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用简介

    jdk1.5并发新特性.

    JDK 1.5 引入了一系列重要的并发编程新特性,极大地改善了多线程环境下的程序设计。这些特性使得开发者能够编写更加高效、安全的并发应用程序。以下是对这些新特性的详细解释: 1. `TimeUnit`: `TimeUnit` 是一个...

    jdk1.5 线程并发与线程池的使用

    在Java编程语言中,线程并发和线程池是多任务执行的核心概念,尤其是在JDK 1.5及以后的版本中得到了显著增强。线程并发允许程序同时执行多个任务,提高了程序的效率和响应性。线程池是管理线程资源的有效方式,通过...

    java JDK1.5实例宝典

    《Java JDK1.5实例宝典》是一本深入解析JDK1.5版本中关键特性和类库的实践指南,涵盖了Java Mail、Servlet、JSP以及多线程等多个核心领域。这本书通过丰富的实例来帮助读者理解和掌握Java编程的精髓。 在JDK1.5中,...

    JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用

    "JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用" JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用是Java多线程编程中的一种重要概念。随着多线程编程的普及,线程池的使用变得...

    JDK1.5 JAVA

    在并发处理方面,JDK1.5引入了并发工具包(java.util.concurrent),包括线程池、并发容器和同步原语等,提供了高效且易于使用的多线程编程工具,大大改善了Java的并发性能。 最后,JDK1.5对垃圾回收机制进行了优化...

Global site tag (gtag.js) - Google Analytics