java的5种线程池的分析和简单使用

一、线程池简介

java通过Executors提供五种线程池,都是直接或间接继承自ThreadPoolExcecutor 线程池类,他们都是有特殊的功能,如果不是必须用这几个特殊的线程池类,也可以直接new ThreadPoolExcecutors 线程池来用。

二、线程池使用好处

使用线程池的好处:

1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池,有可能造成系统创建大量线程而导致消耗完系统内存

以下是Java自带的几种线程池:

1、newFixedThreadPool 创建一个指定工作线程数量的线程池。

每当提交一个任务就创建一个工作线程,如果工作线程数量达到线程池初始的最大数,则将提交的任务存入到池队列中。

2、newCachedThreadPool 创建一个可缓存的线程池。

这种类型的线程池特点是:

1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。

2).如果长时间没有往线程池中提交任务,即如果工作线程空闲了指定的时间(默认为1分钟),则该工作线程将自动终止。终止后,如果你又提交了新的任务,则线程池重新创建一个工作线程。

3、newSingleThreadExecutor 创建一个单线程化的Executor,即只创建唯一的工作者线程来执行任务,如果这个线程异常结束,会有另一个取代它,保证顺序执行(我觉得这点是它的特色)。

单工作线程最大的特点是可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的 。

4、newScheduleThreadPool 创建一个定长的线程池,而且支持定时的以及周期性的任务执行,类似于Timer。

总结:

1.FixedThreadPool是一个典型且优秀的线程池,它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但在线程池空闲时,即线程池中没有可运行任务时,它不会释放工作线程,还会占用一定的系统资源。

2.CachedThreadPool的特点就是在线程池空闲时,即线程池中没有可运行任务时,它会释放工作线程,从而释放工作线程所占用的资源。但是,但当出现新任务时,又要创建一新的工作线程,又要一定的系统开销。并且,在使用CachedThreadPool时,一定要注意控制任务的数量,否则,由于大量线程同时运行,很有会造成系统瘫痪。

三、具体实例

package xiaobai;

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * 56 行用 Executors.newFixedThreadPool(3) 创建线程池,其实完全可以用new ThreadPoolExecutor() 创建,因为后者是前者的底层调用
 * 以下四种线程池是继承自ThreadPoolExecutor() 这个根线程池的,
 */
public class ThreadPoolExecutorTest {
	
	/**
	 * newCachedThreadPool
	 * @throws InterruptedException 
	 * @
	 */
	public static void newCachedThreadPoolTest() throws InterruptedException {
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		for(int i=0;i<10;i++) {
			final int index = i;
//			try {
//				Thread.sleep(index * 100);
//			} catch (InterruptedException e) {
//				e.printStackTrace();
//			} 
			cachedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println("current Thread name is " + Thread.currentThread().getName() 
							+ " index: " + index);
				}
			});
		}
		Thread.sleep(200);
		//cachedThreadPool.shutdown();//.awaitTermination(10, TimeUnit.SECONDS);  //这个函数功能存疑
		System.out.println("cachedThreadPool isShutdown() is : "+ cachedThreadPool.isShutdown()); //上行不注释,则结果为false,上行不注释,则结果为true
		System.out.println("cachedThreadPool isTerminated() is : "+cachedThreadPool.isTerminated());//上上行注释不注释,结果均为false
		
		cachedThreadPool.execute(new Runnable() {  // cachedThreadPool shutdown 之后,这个execute() 不能之前且会报异常
			@Override
			public void run() { 
				System.out.println("cachedThreadPool is not shutdown and this task can be executing. "
						+ "\n current Thread name is " + Thread.currentThread().getName());
			}
		});
	}
	/**
	 * newFixedThreadPool
	 */
	public static void fixedThreadPoolTest() {
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); //这个函数返回的是 ThreadPoolExecutor
		for(int i=0;i<10;i++) {
			final int index = i;
			fixedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println("current Thread name is " + Thread.currentThread().getName() + " index : " + index);
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
		System.out.println("10个任务已分发完毕"); //这句大概率性优先于run 里面的print 语句先执行
	}
	
	/**
	 * 产生一个ScheduledExecutorService对象,
	 * newScheduledThreadPool(3),这个对象的线程池大小为3,若任务数量大于3
	 * 任务会在一个queue里等待执行
	 * scheduleWithFixedDelay 函数:第一个参数new Runnable 就是任务
	 * 所谓线程池,就是能接受任务。线程池的好处是帮你调度线程,不然还得自己写调度多个线程的方法,比如周期性执行任务
	 */
	public static void scheduledThreadPoolTest() {
		//ScheduledExecutorService 只是个接口,ScheduledThreadPoolExecutor 才是实现此接口的类.ScheduledThreadPoolExecutor 还继承了ThreadPoolExecutor 线程池类
		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3); //这个函数返回的是ScheduledThreadPoolExecutor

//			scheduledThreadPool.schedule(new Runnable() { //schedule 是只执行一次,不是周期性的
//				
//				@Override
//				public void run() {
//					System.out.println("delay 3 seconds index is " + index);
//				}
//			}, 3, TimeUnit.SECONDS);
			System.out.println("---------------------");
			scheduledThreadPool.scheduleWithFixedDelay(new Runnable() { //scheduleWithFixedDelay 是周期性的,
				@Override										//scheduleWithFixedDelay()方法不是ThreadPool 类的是ScheduledExecutorService 接口特有的
				public void run() {
					try {
						Thread.sleep(3000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("current Thread name is " + Thread.currentThread().getName() + " time is : " + new Date().getTime());
				}
			}, 1, 1, TimeUnit.SECONDS);
		}
	
	/**
	 * 单线程线程池,保证所有任务都按照指定顺序(FIFO, LIFO, 优先级)执行
	 * @param args
	 */
	public static void singleThreadExecutorTest() {
		ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
		for(int i = 0;i<10;i++) {
			final int index = i;
			singleThreadExecutor.execute(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println("current Thread name is " + Thread.currentThread().getName() + " index : " + index);
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
	}
	/**
	 * (5)
	 */
	public static void SingleThreadScheduledExecutorTest() {
		ScheduledExecutorService scheduledThreadPool = Executors.newSingleThreadScheduledExecutor();
			System.out.println("---------------------");
			scheduledThreadPool.scheduleWithFixedDelay(new Runnable() { //scheduleWithFixedDelay 是周期性的
				@Override
				public void run() {
					try {
						Thread.sleep(3000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("current Thread name is " + Thread.currentThread().getName() + " time is : " + new Date().getTime());
				}
			}, 1, 1, TimeUnit.SECONDS); //第二个参数1,虽然是1秒为周期,但是单线程线程池,如果上一个任务没执行完,那么会等2秒或者更多,
		}								//直到上一个任务执行完,才执行下一个任务。即执行完这个条件优先最高,频率次之
	
	
	public static void main(String[] args) throws InterruptedException {
//		newCachedThreadPoolTest();
//		fixedThreadPoolTest();
//		scheduledThreadPoolTest();
//		singleThreadExecutorTest();
		SingleThreadScheduledExecutorTest();
	}
}