java线程池管理类

杨、怼怼 2015-08-22 07:11:11

面试总被问到线程池可惜我没用过索性自己写一个吧
首先感谢这个作者：
里面有详细的源码讲解 http://www.cnblogs.com/dolphin0520/p/3932921.html Java并发编程：线程池的使用
。
本人菜鸟一枚那里写的不对还望指正

OK进入正题直接上代码（转载请注明原文哦。。）

线程池管理类 ~~~~~



package mine.util.thread;



import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.Future;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;



/**

 * 连接池工具类实例

 * @author YZ

 *

 */

public class ThreadPool {

	//

	private static ThreadPool threadPool;

	private ThreadPoolExecutor executor=null;

	//线程池的基础参数 实际使用可写入到配置文件中

	private int corePoolSize=10;			//核心池的大小 运行线程的最大值 当线程池中的线程数目达到corePoolSize后，就会把多余的任务放到缓存队列当中；

	private int maximumPoolSize=15;		//创建线程最大值 

	private long keepAliveTime =200; 	//线程没有执行任务时 被保留的最长时间 超过这个时间就会被销毁 直到线程数等于 corePoolSize

	/**	参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

	 	TimeUnit.DAYS;               天

		TimeUnit.HOURS;             小时

		TimeUnit.MINUTES;           分钟

		TimeUnit.SECONDS;           秒

		TimeUnit.MILLISECONDS;      毫秒

		TimeUnit.MICROSECONDS;      微妙

		TimeUnit.NANOSECONDS;       纳秒***/

	private TimeUnit unit= TimeUnit.MILLISECONDS;

	/**

	 * 	用来储存等待中的任务的容器

	 * 

	 * 	几种选择：

	 *	ArrayBlockingQueue;

	 *	LinkedBlockingQueue;

	 *	SynchronousQueue;

	 *	区别太罗嗦请百度  http://blog.csdn.net/mn11201117/article/details/8671497

	 */

	private LinkedBlockingQueue workQueue=new LinkedBlockingQueue<Runnable>();

	

	/**

	 * 单例

	 * @return

	 */

	public static ThreadPool init(){

		if(threadPool==null)

			threadPool=new ThreadPool();

		return threadPool;

	}

	

	/**

	 * 私有构造方法 

	 */

	private ThreadPool(){

		//实现线程池

		executor=new ThreadPoolExecutor(corePoolSize,maximumPoolSize, keepAliveTime, unit,

					workQueue);

		System.out.println("线程池初始化成功");

	}

	/**

	 * 线程池获取方法

	 * @return

	 */

	public ThreadPoolExecutor getExecutor() {

		return executor;

	}

	/**

	 *  准备执行 抛入线程池

	 * @param t

	 */

	public void execute(Thread t){

		executor.execute(t);

	}

	public void execute(Runnable t){

		executor.execute(t);

	}

	/**

         *返回 Future

	 * Future.get()可获得返回结果

	 * @return

	 */

	@SuppressWarnings({ "unchecked", "rawtypes" })

	public Future<?> submit(Callable t){

		return getExecutor().submit(t);

	}

        /**

	 * 销毁线程池

	 * */

	public void shutdown(){

	  getExecutor().shutdown();

	}

}

测试一下****



package mine.util.thread;  

  

import java.util.LinkedList;  

import java.util.List;  

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Future;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

  

/** 

 * 线程池类，线程管理器：创建线程，执行任务，销毁线程，获取线程基本信息 

 */  

public class Test {

    public static void main(String[] args) throws InterruptedException, ExecutionException { 

    	//开十个线程 用来开线程 哈哈

    	for(int i=1;i<10;i++){

    	MyTask m2=new MyTask(i);

    	m2.start();

    	}

    }

}





class MyTask  extends Thread {

	   private int taskNum;

	    

	   public MyTask(int num) {

	       this.taskNum = num;

	   }

	   /**

	    * 拿到线程池

	    * */

	   public ThreadPool threadPool= ThreadPool.init();

	    @Override

	   public void run() {

	    	   for(int i=0;i<150;i++){

	           	MyTaskRun myTask = new MyTaskRun(taskNum+"--"+i+"  \n");

	           	//正题 

	           	threadPool.execute(myTask);

	               System.out.println("线程池中线程数目："+threadPool.getExecutor().getPoolSize()+"，队列中等待执行的任务数目："+

	            		   threadPool.getExecutor().getQueue().size()+"，已执行玩别的任务数目："+threadPool.getExecutor().getCompletedTaskCount());

	            }

	           System.out.println("ok--- 线程池中线程数目："+threadPool.getExecutor().getPoolSize()+"，队列中等待执行的任务数目："+

	        		   threadPool.getExecutor().getQueue().size()+"，已执行玩别的任务数目："+threadPool.getExecutor().getCompletedTaskCount());

	    }



	  

	}



class MyTaskRun  implements Runnable{

	   private String taskNum;

	    

	   public MyTaskRun(String num) {

	       this.taskNum = num;

	   }

	   /**

	    * 拿到线程池

	    * */

	   public ThreadPool threadPool= ThreadPool.init();

	   public void run() {

	       try {

	           Thread.currentThread().sleep(1000);

	       } catch (InterruptedException e) {

	           e.printStackTrace();

	       }

	       System.out.println(taskNum+"taskNum 线程池中线程数目 ："+threadPool.getExecutor().getPoolSize()+"，队列中等待执行的任务数目："+

	    		   threadPool.getExecutor().getQueue().size()+"，已执行玩别的任务数目："+threadPool.getExecutor().getCompletedTaskCount());

	   }



	}