多线程之线程池探索

多线程应用执行时JDK提供了线程的载体，线程池，通过线程池管理线程，优化线程的执行，有效合理利用资源。而JDK提供的线程池有四大类：FixedThreadPool，SingleThreadExecutor，CachedThreadPool，ScheduledThreadPool。这四种池各有特点。现在一一来看。

第一，FixedThreadPool,来自jdk的解释是这样的：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。而通过源码

 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

参数说明：第一个nThreads，线程池的线程数。第二个nThreads是线程池中允许的最大线程数。
0L表示多余最大线程数-线程池的线程数的这些线程在闲置情况下允许的存活时间。TimeUnit时间单位。 LinkedBlockingQueue<Runnable> 一个基于已链接节点的、范围任意的 blocking queue。备注：还有可能有一个参数threadFactory用来创建线程。

可以看到线程池有一个LinkedBlockingQueue<Runnable>队列来存放过量的任务（也就是JDK中所说的附加任务）。所以，这个固定大小的线程池的好处在于，无论是流量高峰还是没有访问装态，都会最多有nThreads在线程池（如果某一瞬间，某些线程down掉后，没来的急新建，那就少于这个值了），这样的话能够尽量保证消耗的内存空间较少，能够避免一些线程数猛增带来的OOM问题。

第二：SingleThreadExecutor。来自jdk的解释：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

源码：

 public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

说明：只是池大小为1了。
分析：此种池的特点在于永远只有一个有效线程在运行，也就成了多个任务串行执行了，对于前后任务有顺序的多任务可能有所帮助。

第三：CachedThreadPool。来自jdk的解释：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。

参见创建源码：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

说明：这个池建立参数上比较特殊，它允许最大 Integer.MAX_VALUE个线程共存，并且设置了60秒线程的闲置限制。并采用了奇怪的SynchronousQueue。这个队列是这样的，看jdk api文档：
一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。不能在同步队列上进行 peek，因为仅在试图要移除元素时，该元素才存在；除非另一个线程试图移除某个元素，否则也不能（使用任何方法）插入元素；也不能迭代队列，因为其中没有元素可用于迭代。队列的头 是尝试添加到队列中的首个已排队插入线程的元素；如果没有这样的已排队线程，则没有可用于移除的元素并且 poll() 将会返回 null。对于其他 Collection 方法（例如 contains），SynchronousQueue 作为一个空 collection。此队列不允许 null 元素。

分析：这种池的特点在于能根据任务的数量设置池中线程多少，并能在一段时间后清除闲置线程，但是风险在于允许太多的线程存在，这就会导致线程创建的资源消耗过多。


第四：ScheduledThreadPool。来自jdk的解释：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
创建源码：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

该池最大的特点在于允许你定时delay后按照一定的速率隔时执行一些任务。

简要的理解了这几种池之后通过几个demo来进一步认识下哈。 源码是王道。恩直接看吧：

这个例子主要是理解下四个池的特点，针对runnable和callable任务的一些测试。

package ThreadSPools;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolDemo {

public static void main(String[] args){
		 Thread main = Thread.currentThread();
		final HashMap<Integer, ArrayList<Integer>>  map = new HashMap<Integer,ArrayList<Integer>>(); 
		HashMap<Integer, ArrayList<Integer>> resultMap  = new HashMap<Integer,ArrayList<Integer>>();
		
		for(int i=0;i<300;i++){
			ArrayList<Integer> arrayList= new ArrayList<Integer>(); 
			for(int i1=0;i1<10000;i1++){
				int p = (int) (Math.random()*10000);
				arrayList.add(p);
			}
			map.put(i, arrayList);
		}
		//ExecutorService  executor = Executors.newFixedThreadPool(2);
		//ExecutorService  executor = Executors.newSingleThreadExecutor();
		ExecutorService  executor = Executors.newCachedThreadPool();
		//ExecutorService  executor = Executors.newScheduledThreadPool(4);
		long start = System.currentTimeMillis();
		for(final int key : map.keySet()){
			Callable<ArrayList<Integer>> task = new Callable<ArrayList<Integer>>(){

				@Override
				public ArrayList<Integer>call()
						throws Exception {
					Collections.sort(map.get(key));
					return map.get(key);
				}
				
			};
			Future<ArrayList<Integer>> future=executor.submit(task);
			try {
				resultMap.put(key, future.get());
				System.out.println(key+" "+resultMap.get(key).subList(0, 10));
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	
		long end = System.currentTimeMillis();	
		try {
			main.sleep(6000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("Excuting this totally costs "+(end - start));
		executor.shutdown();
		
	}
}

另外看一个自己修正的简要池，主要是用来测RejectedExecutionHandler策略以及選取的BlockingQueue<Runnable>。

源码：

package ThreadSPools;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
//一個類似于cachedPool的ThreadPool 主要用來測試任務的RejectedExecutionHandler策略以及選取的BlockingQueue<Runnable>
public class ThreadPoolOwnedByShuofengDemo extends ThreadPoolExecutor{
	
	public ThreadPoolOwnedByShuofengDemo(int nThreads,int maxnThreads,
			long keepaliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,
			ThreadFactory threadfactory,RejectedExecutionHandler handler){
		 
		super(nThreads,maxnThreads,keepaliveTime,
				TimeUnit.SECONDS, workQueue,
				threadfactory,handler);
	}
	
	
	public  static void main(String[]args){
		
		ThreadPoolOwnedByShuofengDemo pool = 
			new ThreadPoolOwnedByShuofengDemo(5,10,30,TimeUnit.SECONDS,
					//使用這個隊列時，大於這個隊列的容量后，基本上直接拋出RejectedExecutionException
					//new ArrayBlockingQueue<Runnable>(10)
					
					//new LinkedBlockingQueue<Runnable>()//使用這個隊列時，基本上RejectedExecutionHandler沒用了
					
					//沒有空間冗餘，也就是說當任務數大於當前可執行的數量時，一般都直接拋出RejectedExecutionException
					//偶爾比較幸運當期執行的任務完成，那就會執行后提交的一個，不過這個概率貌似很小一樣，除非提交任務的時間點靠後
					new SynchronousQueue<Runnable>()
					,
					Executors.defaultThreadFactory(),
					//当多于 maxnThread +ArrayBlockingQueue大小时抛出异常RejectedExecutionException
					new AbortPolicy() 
					//当任务数瞬间多于 maxnThread +ArrayBlockingQueue大小时，将任务退回给调用线程执行
					//new CallerRunsPolicy()  
					//任务数瞬间多于 maxnThread +ArrayBlockingQueue大小时，后来任务被丢掉
					//new DiscardPolicy()
					//任务数瞬间多于 maxnThread +ArrayBlockingQueue大小时，最早提交还未被执行的任务被丢掉
					//new DiscardOldestPolicy()
			);
		
		final CopyOnWriteArrayList<String> arraylist = new CopyOnWriteArrayList<String>();
		//测试runnable task
//		for(int i=0;i<50;i++){
//			Runnable task = new Runnable(){
//
//				@Override
//				public void run() {
//					
//					System.out.println(Thread.currentThread().getName()+"  hello,this is shuofengTask.");
//					try {
//						Thread.currentThread().sleep(1000);
//					} catch (InterruptedException e) {
//						// TODO Auto-generated catch block
//						e.printStackTrace();
//					}
//				}
//				
//			};
//			pool.submit(task);
//		}
		//测试Callable task
		for(int i=0;i<10;i++){
			final int id= i;
			Callable task = new Callable(){

				final String taskname= id+"号task"; 
				@Override
				public Object call() throws Exception {
					String s =taskname+"  hello,this is shuofengTask.";
					
					arraylist.add(s);
					
					try {
						Thread.currentThread().sleep(1);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					return arraylist;
				}
				
			};
			
			pool.submit(task);
		}
		
		try {
			Thread.currentThread().sleep(1000);//sleep时间要合理 保证在池关闭前任务已经都执行完了
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(arraylist.size());
		System.out.println(arraylist.subList(0, arraylist.size()));
		pool.shutdown();//优雅的关闭池资源
	}
	
	
	
}

再看一下最奇怪的同步队列

package SychQueue;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;
//特点在于每一个消费者都要等生产者放入字符串之后才能读取。而且同步队列没有容量，如果消费者不取的话，则会被阻塞。
public class SynchronousQueueDemo {

	public static void main(String[]args){
		final List<String> msg = Arrays.asList("start","one","two","three"); 
		final BlockingQueue<String> queue = new SynchronousQueue<String>();
		ExecutorService  executor = Executors.newCachedThreadPool();
		Runnable producerTask = new Runnable(){
			final List<String> waitingRecievingMsg = msg;
			@Override
			public void run() {
				
					try {
						for(String s:waitingRecievingMsg){
							queue.put(s);
							Thread.currentThread().sleep(1000);
						}
						queue.put("end");
						
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			
		};
		executor.submit(producerTask);
		
		Runnable consumerTask = new Runnable(){
			String recievedMsg;
			@Override
			public void run() {
				try {
					;
					while((recievedMsg = queue.take())!=null&& !recievedMsg.equals("end")){
						System.out.println(recievedMsg);
						Thread.currentThread().sleep(3000);
					}
					
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};
		executor.submit(consumerTask);
		executor.shutdown();
	}
	
}

说明：

线程池其实也是比较简单的 ，只要记住将任务按照需要组装成runnale 或者callable形式（两者的区别在于有无返回值），然后选择合适的池类型，将任务提交就可以了。只是要注意多个任务的时候  控制任务的到达等，然后要注意的就是合适的时机关闭线程池了。