关于java中线程池介绍及使用

这几天主要是狂看源程序，在弥补了一些以前知识空白的同时，也学会了不少新的知识或者称为新技术吧。

线程池就是其中之一，一提到线程，我们会想到以前《操作系统》的生产者与消费者，信号量，同步控制等等。

一提到池，我们会想到数据库连接池，但是线程池又如何呢？

建议：在阅读本文前，先理一理同步的知识，特别是syncronized同步关键字的用法。

简单介绍

    创建线程有两种方式：继承Thread或实现Runnable。Thread实现了Runnable接口，提供了一个空的run()方法，所以不论是继承Thread还是实现Runnable，都要有自己的run()方法。

线程池：

    多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。    

    假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

    如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。

                一个线程池包括以下四个基本组成部分：

                1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；

                2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；

                3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；

                4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。

    线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：

假设一个服务器一天要处理100000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为100000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建100000而在处理请求时浪费时间，从而提高效率。

/** 线程池类，工作线程作为其内部类 **/

package org.jimmy.main;

import java.util.Collections;

import java.util.Date;

import java.util.LinkedList;

import java.util.List;

public final class ThreadPool {

private staticbooleandebug =true;

// private static boolean debug = taskLogger.isInfoEnabled();

/* 单例 */

private static ThreadPoolinstance = ThreadPool.getInstance();

publicstaticfinalintSYSTEM_BUSY_TASK_COUNT = 150;

/* 默认池中线程数 */

public staticintworker_num = 5;

/* 已经处理的任务数 */

private staticinttaskCounter = 0;

public staticbooleansystemIsBusy =false;

private static List<Task>taskQueue = Collections

.synchronizedList(new LinkedList<Task>());

/* 池中的所有线程 */

public PoolWorker[] workers;

private ThreadPool() {

workers = new PoolWorker[5];

for (int i = 0; i <workers.length; i++) {

workers[i] =new PoolWorker(i);

}

}

private ThreadPool(int pool_worker_num) {

worker_num = pool_worker_num;

workers = new PoolWorker[worker_num];

for (int i = 0; i <workers.length; i++) {

workers[i] =new PoolWorker(i);

}

}

public staticsynchronized ThreadPool getInstance() {

if (instance ==null)

returnnew ThreadPool();

returninstance;

}

/**

* 增加新的任务 每增加一个新任务，都要唤醒任务队列

* 

* @param newTask

*/

public void addTask(Task newTask) {

synchronized (taskQueue) {

newTask.setTaskId(++taskCounter);

newTask.setSubmitTime(new Date());

taskQueue.add(newTask);

/* 唤醒队列, 开始执行 */

taskQueue.notifyAll();

}

System.out.println("Submit Task<" + newTask.getTaskId() +">: "

+ newTask.info());

}

/**

* 批量增加新任务

* 

* @param taskes

*/

public void batchAddTask(Task[] taskes) {

if (taskes == null || taskes.length == 0) {

return;

}

synchronized (taskQueue) {

for (int i = 0; i < taskes.length; i++) {

if (taskes[i] ==null) {

continue;

}

taskes[i].setTaskId(++taskCounter);

taskes[i].setSubmitTime(new Date());

taskQueue.add(taskes[i]);

}

/* 唤醒队列, 开始执行 */

taskQueue.notifyAll();

}

for (int i = 0; i < taskes.length; i++) {

if (taskes[i] ==null) {

continue;

}

System.out.println("Submit Task<" + taskes[i].getTaskId() +">: "

+ taskes[i].info());

}

}

/**

* 线程池信息

* 

* @return

*/

public String getInfo() {

StringBuffer sb = new StringBuffer();

sb.append("\nTask Queue Size:" +taskQueue.size());

for (int i = 0; i <workers.length; i++) {

sb.append("\nWorker " + i +" is "

+ ((workers[i].isWaiting()) ?"Waiting." :"Running."));

}

return sb.toString();

}

/**

* 销毁线程池

*/

public synchronizedvoid destroy() {

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

workers[i].stopWorker();

workers[i] =null;

}

taskQueue.clear();

}

/**

* 池中工作线程

* 

* @author obullxl

*/

private class PoolWorkerextends Thread {

private int index = -1;

/* 该工作线程是否有效 */

privatebooleanisRunning =true;

/* 该工作线程是否可以执行新任务 */

privatebooleanisWaiting =true;

public PoolWorker(int index) {

this.index = index;

start();

}

public void stopWorker() {

this.isRunning =false;

}

public boolean isWaiting() {

returnthis.isWaiting;

}

/**

* 循环执行任务 这也许是线程池的关键所在

*/

public void run() {

while (isRunning) {

Task r = null;

synchronized (taskQueue) {

while (taskQueue.isEmpty()) {

try {

/* 任务队列为空，则等待有新任务加入从而被唤醒 */

taskQueue.wait(20);

}catch (InterruptedException ie) {

}

}

/* 取出任务执行 */

r = (Task)taskQueue.remove(0);

}

if (r !=null) {

isWaiting =false;

try {

if (debug) {

r.setBeginExceuteTime(new Date());

System.out.println("Worker<" +index

+"> start execute Task<" + r.getTaskId()

+">");

if (r.getBeginExceuteTime().getTime()

- r.getSubmitTime().getTime() > 1000)

System.out.println("longer waiting time. "

+ r.info()

+",<"

+index

+">,time:"

+ (r.getFinishTime().getTime() - r

.getBeginExceuteTime()

.getTime()));

}

/* 该任务是否需要立即执行 */

if (r.needExecuteImmediate()) {

new Thread(r).start();

}else {

r.run();

}

if (debug) {

r.setFinishTime(new Date());

System.out.println("Worker<" +index

+"> finish task<" + r.getTaskId() +">");

if (r.getFinishTime().getTime()

- r.getBeginExceuteTime().getTime() > 1000)

System.out.println("longer execution time. "

+ r.info()

+",<"

+index

+">,time:"

+ (r.getFinishTime().getTime() - r

.getBeginExceuteTime()

.getTime()));

}

} catch (Exception e) {

e.printStackTrace();

}

isWaiting =true;

r =null;

}

}

}

}

}

package org.jimmy.main;

import java.util.Date;

public abstract class Taskimplements Runnable {

// private static Logger logger = Logger.getLogger(Task.class);

/* 产生时间 */

private DategenerateTime =null;

/* 提交执行时间 */

private Date submitTime = null;

/* 开始执行时间 */

private DatebeginExceuteTime =null;

/* 执行完成时间 */

private Date finishTime = null;

private longtaskId;

public Task() {

this.generateTime =new Date();

}

/**

* 任务执行入口

*/

public void run() {

/**

* 相关执行代码

* 

* beginTransaction();

* 

* 执行过程中可能产生新的任务 subtask = taskCore();

* 

* commitTransaction();

* 

* 增加新产生的任务 ThreadPool.getInstance().batchAddTask(taskCore());

*/

}

/**

* 所有任务的核心 所以特别的业务逻辑执行之处

* 

* @throws Exception

*/

public abstract Task[] taskCore()throws Exception;

/**

* 是否用到数据库

* 

* @return

*/

protected abstractboolean useDb();

/**

* 是否需要立即执行

* 

* @return

*/

protected abstractboolean needExecuteImmediate();

/**

* 任务信息

* 

* @return String

*/

public abstract String info();

public Date getGenerateTime() {

returngenerateTime;

}

public Date getBeginExceuteTime() {

returnbeginExceuteTime;

}

public void setBeginExceuteTime(Date beginExceuteTime) {

this.beginExceuteTime = beginExceuteTime;

}

public Date getFinishTime() {

returnfinishTime;

}

public void setFinishTime(Date finishTime) {

this.finishTime = finishTime;

}

public Date getSubmitTime() {

returnsubmitTime;

}

public void setSubmitTime(Date submitTime) {

this.submitTime = submitTime;

}

public long getTaskId() {

returntaskId;

}

public void setTaskId(long taskId) {

this.taskId = taskId;

}

}

上面的代码简单的描述了线程池的内部实现，建议根据里面的例子来了解JAVA 线程池的原理。大家可以研究下
    JDK自带线程池总类介绍介绍： 

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

    2、newCachedThreadPool创建一个可缓存的线程池。这种类型的线程池特点是： 
    1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。 
    2).如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。 

    3、newSingleThreadExecutor创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的 。 

    4、newScheduleThreadPool创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。(这种线程池原理暂还没完全了解透彻) 

    总结： 

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

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