Java 线程池的原理与实现

这几天主要是狂看源程序，在弥补了一些以前知识空白的同时，也学会了不少新的知识（比如 NIO），或者称为新技术吧。
线程池就是其中之一，一提到线程，我们会想到以前《操作系统》的生产者与消费者，信号量，同步控制等等。
一提到池，我们会想到数据库连接池，但是线程池又如何呢？


建议 ：在阅读本文前，先理一理同步的知识，特别是syncronized同步关键字的用法。
关于我对同步的认识，要缘于大三年的一本书，书名好像是 Java 实战，这本书写得实在太妙了，真正的从理论到实践，从截图分析到.class字节码分析。哇，我想市场上很难买到这么精致的书了。作为一个Java爱好者，我觉得绝对值得一读。
我对此书印象最深之一的就是：equal()方法，由浅入深，经典！
还有就是同步了，其中提到了我的几个编程误区，以前如何使用同步提高性能等等，通过学习，使我对同步的认识进一步加深。


简单介绍

    创建线程有两种方式：继承Thread或实现Runnable。Thread实现了Runnable接口，提供了一个空的run()方法，所以不论是继承Thread还是实现Runnable，都要有自己的run()方法。
    一个线程创建后就存在，调用start()方法就开始运行（执行run()方法），调用wait进入等待或调用sleep进入休眠期，顺利运行完毕或休眠被中断或运行过程中出现异常而退出。

wait和sleep比较：
      sleep方法有：sleep(long millis)，sleep(long millis, long nanos)，调用sleep方法后，当前线程进入休眠期，暂停执行，但该线程继续拥有监视资源的所有权。到达休眠时间后线程将继续执行，直到完成。若在休眠期另一线程中断该线程，则该线程退出。
      wait方法有：wait()，wait(long timeout)，wait(long timeout, long nanos)，调用wait方法后，该线程放弃监视资源的所有权进入等待状态；
      wait()：等待有其它的线程调用notify()或notifyAll()进入调度状态，与其它线程共同争夺监视。wait()相当于wait(0)，wait(0, 0)。
      wait(long timeout)：当其它线程调用notify()或notifyAll()，或时间到达timeout亳秒，或有其它某线程中断该线程，则该线程进入调度状态。
      wait(long timeout, long nanos)：相当于wait(1000000*timeout + nanos)，只不过时间单位为纳秒。



线程池：
    多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
    
    假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。
    
    如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
                一个线程池包括以下四个基本组成部分：
                1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；
                2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
                3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
                4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
                
    线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

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

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

view source

print?

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

002  

003package org.ymcn.util;

004  

005import java.util.Collections;

006import java.util.Date;

007import java.util.LinkedList;

008import java.util.List;

009  

010import org.apache.log4j.Logger;

011  

012/**

013* 线程池

014* 创建线程池，销毁线程池，添加新任务

015* 

016* <A class=referer href="http://my.oschina.net/arthor" target=_blank>@author</A>  obullxl

017*/

018public final class ThreadPool {

019    privatestatic Logger logger = Logger.getLogger(ThreadPool.class);

020    privatestatic Logger taskLogger = Logger.getLogger("TaskLogger");

021  

022    privatestatic booleandebug = taskLogger.isDebugEnabled();

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

024    /* 单例 */

025    private static ThreadPool instance = ThreadPool.getInstance();

026  

027    public static final int SYSTEM_BUSY_TASK_COUNT = 150;

028    /* 默认池中线程数 */

029    public static int worker_num = 5;

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

031    private static int taskCounter = 0;

032  

033    public static boolean systemIsBusy = false;

034  

035    private static List<Task> taskQueue = Collections

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

037    /* 池中的所有线程 */

038    public PoolWorker[] workers;

039  

040    private ThreadPool() {

041        workers = new PoolWorker[5];

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

043            workers[i] = new PoolWorker(i);

044        }

045    }

046  

047    private ThreadPool(int pool_worker_num) {

048        worker_num = pool_worker_num;

049        workers = new PoolWorker[worker_num];

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

051            workers[i] = new PoolWorker(i);

052        }

053    }

054  

055    public static synchronized ThreadPool getInstance() {

056        if (instance == null)

057            return new ThreadPool();

058        return instance;

059    }

060    /**

061    * 增加新的任务

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

063    * @param newTask

064    */

065    public void addTask(Task newTask) {

066        synchronized (taskQueue) {

067            newTask.setTaskId(++taskCounter);

068            newTask.setSubmitTime(new Date());

069            taskQueue.add(newTask);

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

071            taskQueue.notifyAll();

072        }

073        logger.info("Submit Task<" + newTask.getTaskId() + ">: "

074                + newTask.info());

075    }

076    /**

077    * 批量增加新任务

078    * @param taskes

079    */

080    public void batchAddTask(Task[] taskes) {

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

082            return;

083        }

084        synchronized (taskQueue) {

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

086                if (taskes[i] == null) {

087                    continue;

088                }

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

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

091                taskQueue.add(taskes[i]);

092            }

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

094            taskQueue.notifyAll();

095        }

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

097            if (taskes[i] == null) {

098                continue;

099            }

100            logger.info("Submit Task<" + taskes[i].getTaskId() + ">: "

101                    + taskes[i].info());

102        }

103    }

104    /**

105    * 线程池信息

106    * <A class=referer href="http://my.oschina.net/u/556800" target=_blank>@return</A> 

107    */

108    public String getInfo() {

109        StringBuffer sb = new StringBuffer();

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

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

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

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

114        }

115        return sb.toString();

116    }

117    /**

118    * 销毁线程池

119    */

120    public synchronized void destroy() {

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

122            workers[i].stopWorker();

123            workers[i] = null;

124        }

125        taskQueue.clear();

126    }

127  

128    /**

129    * 池中工作线程

130    * 

131    * <A class=referer href="http://my.oschina.net/arthor" target=_blank>@author</A>  obullxl

132    */

133    private class PoolWorker extends Thread {

134        private int index = -1;

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

136        private boolean isRunning = true;

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

138        private boolean isWaiting = true;

139  

140        public PoolWorker(int index) {

141            this.index = index;

142            start();

143        }

144  

145        public void stopWorker() {

146            this.isRunning = false;

147        }

148  

149        public boolean isWaiting() {

150            return this.isWaiting;

151        }

152        /**

153        * 循环执行任务

154        * 这也许是线程池的关键所在

155        */

156        public void run() {

157            while (isRunning) {

158                Task r = null;

159                synchronized (taskQueue) {

160                    while (taskQueue.isEmpty()) {

161                        try {

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

163                            taskQueue.wait(20);

164                        } catch (InterruptedException ie) {

165                            logger.error(ie);

166                        }

167                    }

168                    /* 取出任务执行 */

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

170                }

171                if (r != null) {

172                    isWaiting = false;

173                    try {

174                        if (debug) {

175                            r.setBeginExceuteTime(new Date());

176                            taskLogger.debug("Worker<" + index

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

178                            if (r.getBeginExceuteTime().getTime()

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

180                                taskLogger.debug("longer waiting time. "

181                                        + r.info() + ",<" + index + ">,time:"

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

183                                                .getBeginExceuteTime().getTime()));

184                        }

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

186                        if (r.needExecuteImmediate()) {

187                            new Thread(r).start();

188                        } else {

189                            r.run();

190                        }

191                        if (debug) {

192                            r.setFinishTime(new Date());

193                            taskLogger.debug("Worker<" + index

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

195                            if (r.getFinishTime().getTime()

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

197                                taskLogger.debug("longer execution time. "

198                                        + r.info() + ",<" + index + ">,time:"

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

200                                                .getBeginExceuteTime().getTime()));

201                        }

202                    } catch (Exception e) {

203                        e.printStackTrace();

204                        logger.error(e);

205                    }

206                    isWaiting = true;

207                    r = null;

208                }

209            }

210        }

211    }

212}

213  

214/** 任务接口类 **/

215  

216package org.ymcn.util;

217  

218import java.util.Date;

219  

220/**

221* 所有任务接口

222* 其他任务必须继承访类

223* 

224* <A class=referer href="http://my.oschina.net/arthor" target=_blank>@author</A>  obullxl

225*/

226public abstract class Task implements Runnable {

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

228    /* 产生时间 */

229    private Date generateTime = null;

230    /* 提交执行时间 */

231    private Date submitTime = null;

232    /* 开始执行时间 */

233    private Date beginExceuteTime = null;

234    /* 执行完成时间 */

235    private Date finishTime = null;

236  

237    private long taskId;

238  

239    public Task() {

240        this.generateTime = new Date();

241    }

242  

243    /**

244    * 任务执行入口

245    */

246    public void run() {

247        /**

248        * 相关执行代码

249        * 

250        * beginTransaction();

251        * 

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

253        * 

254        * commitTransaction();

255        * 

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

257        */

258    }

259  

260    /**

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

262    * 

263    * @throws Exception

264    */

265    public abstract Task[] taskCore() throws Exception;

266  

267    /**

268    * 是否用到数据库

269    * 

270    * <A class=referer href="http://my.oschina.net/u/556800" target=_blank>@return</A> 

271    */

272    protected abstract boolean useDb();

273  

274    /**

275    * 是否需要立即执行

276    * 

277    * <A class=referer href="http://my.oschina.net/u/556800" target=_blank>@return</A> 

278    */

279    protected abstract boolean needExecuteImmediate();

280  

281    /**

282    * 任务信息

283    * 

284    * <A class=referer href="http://my.oschina.net/u/556800" target=_blank>@return</A>  String

285    */

286    publicabstract String info();

287  

288    publicDate getGenerateTime() {

289        returngenerateTime;

290    }

291  

292    publicDate getBeginExceuteTime() {

293        returnbeginExceuteTime;

294    }

295  

296    publicvoid setBeginExceuteTime(Date beginExceuteTime) {

297        this.beginExceuteTime = beginExceuteTime;

298    }

299  

300    publicDate getFinishTime() {

301        returnfinishTime;

302    }

303  

304    publicvoid setFinishTime(Date finishTime) {

305        this.finishTime = finishTime;

306    }

307  

308    publicDate getSubmitTime() {

309        returnsubmitTime;

310    }

311  

312    publicvoid setSubmitTime(Date submitTime) {

313        this.submitTime = submitTime;

314    }

315  

316    publiclong getTaskId() {

317        returntaskId;

318    }

319  

320    publicvoid setTaskId(longtaskId) {

321        this.taskId = taskId;

322    }

323  

324}

 

转自：http://hi.baiducom/obullxl/blog/item/ee50ad1ba8e8ff1f8718bf66.html