原文地址：http://sunnylocus.iteye.com/blog/223327
程池的作用:
线程池作用就是限制系统中执行线程的数量。
根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。
为什么要用线程池:
线程池代码：
package com.tdt.impl.ls;
import java.util.LinkedList;
/**
* @project LocationGateway
* @author sunnylocus
* @verson 1.0.0
* @date Aug 2, 2008
* @jdk 1.4.2
*/
public class ThreadPool extends ThreadGroup {
private boolean isClosed = false; //线程池是否关闭
private LinkedList workQueue; //工作队列
private static int threadPoolID = 1; //线程池的id
public ThreadPool(int poolSize) { //poolSize 表示线程池中的工作线程的数量
super(threadPoolID + ""); //指定ThreadGroup的名称
setDaemon(true); //继承到的方法，设置是否守护线程池
workQueue = new LinkedList(); //创建工作队列
for(int i = 0; i < poolSize; i++) {
new WorkThread(i).start(); //创建并启动工作线程,线程池数量是多少就创建多少个工作线程
}
}
/** 向工作队列中加入一个新任务,由工作线程去执行该任务*/
public synchronized void execute(Runnable task) {
if(isClosed) {
throw new IllegalStateException();
}
if(task != null) {
workQueue.add(task);//向队列中加入一个任务
notify(); //唤醒一个正在getTask()方法中待任务的工作线程
}
}
/** 从工作队列中取出一个任务,工作线程会调用此方法*/
private synchronized Runnable getTask(int threadid) throws InterruptedException {
while(workQueue.size() == 0) {
if(isClosed) return null;
System.out.println("工作线程"+threadid+"等待任务...");
wait(); //如果工作队列中没有任务,就等待任务
}
System.out.println("工作线程"+threadid+"开始执行任务...");
return (Runnable) workQueue.removeFirst(); //反回队列中第一个元素,并从队列中删除
}
/** 关闭线程池 */
public synchronized void closePool() {
if(! isClosed) {
waitFinish(); //等待工作线程执行完毕
isClosed = true;
workQueue.clear(); //清空工作队列
interrupt(); //中断线程池中的所有的工作线程,此方法继承自ThreadGroup类
}
}
/** 等待工作线程把所有任务执行完毕*/
public void waitFinish() {
synchronized (this) {
isClosed = true;
notifyAll(); //唤醒所有还在getTask()方法中等待任务的工作线程
}
Thread[] threads = new Thread[activeCount()]; //activeCount() 返回该线程组中活动线程的估计值。
int count = enumerate(threads); //enumerate()方法继承自ThreadGroup类，根据活动线程的估计值获得线程组中当前所有活动的工作线程
for(int i =0; i < count; i++) { //等待所有工作线程结束
try {
threads[i].join(); //等待工作线程结束
}catch(InterruptedException ex) {
ex.printStackTrace();
}
}
}
/**
* 内部类,工作线程,负责从工作队列中取出任务,并执行
* @author sunnylocus
*/
private class WorkThread extends Thread {
private int id;
public WorkThread(int id) {
//父类构造方法,将线程加入到当前ThreadPool线程组中
super(ThreadPool.this,id+"");
this.id =id;
}
public void run() {
while(! isInterrupted()) { //isInterrupted()方法继承自Thread类，判断线程是否被中断
Runnable task = null;
try {
task = getTask(id); //取出任务
}catch(InterruptedException ex) {
ex.printStackTrace();
}
//如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
if(task == null) return;
try {
task.run(); //运行任务
}catch(Throwable t) {
t.printStackTrace();
}
}// end while
}// end run
}// end workThread
}
测试用例代码：
package com.tdt.test;
import com.tdt.impl.ls.ThreadPool;
public class ThreadPoolTest {
public static void main(String[] args) throws InterruptedException {
ThreadPool threadPool = new ThreadPool(3); //创建一个有个3工作线程的线程池
Thread.sleep(500); //休眠500毫秒,以便让线程池中的工作线程全部运行
//运行任务
for (int i = 0; i <=5 ; i++) { //创建6个任务
threadPool.execute(createTask(i));
}
threadPool.waitFinish(); //等待所有任务执行完毕
threadPool.closePool(); //关闭线程池
}
private static Runnable createTask(final int taskID) {
return new Runnable() {
public void run() {
// System.out.println("Task" + taskID + "开始");
System.out.println("Hello world");
// System.out.println("Task" + taskID + "结束");
}
};
}
}
运行结果：
View Code
1 工作线程0等待任务... 2 工作线程1等待任务... 3 工作线程2等待任务... 4 5 工作线程0开始执行任务... 6 Hello world 7 工作线程0等待任务... 8 9 工作线程1开始执行任务... 10 Hello world 11 工作线程1等待任务... 12 13 工作线程2开始执行任务... 14 Hello world 15 工作线程2等待任务... 16 17 工作线程0开始执行任务... 18 Hello world 19 工作线程0等待任务... 20 21 工作线程1开始执行任务... 22 Hello world 23 工作线程1等待任务... 24 25 工作线程2开始执行任务... 26 Hello world 27 工作线程2等待任务...
——————————————————————以上是转贴的原文————————————————————————————————————————ThreadGroup 介绍
Class ThreadGroup
属于 java.lang.ThreadGroup
线程组是代表一组线程的集合。此外，一个线程组还可以包括其他的线程组。线程组构成一棵树，除了初始线程组的线程组，其中每有一个父。
允许一个线程访问其自己的线程组的信息，但不能访问有关其线程组的父线程组或任何其他线程组的信息。
每一个线程产生时，都会被归入某个线程组，视线程是在哪个线程组中产生而定。如果没有指定，则归入产生该子线程的线程组中。您也可以自行指定线程组，线程一旦归入某个组，就无法更换组。
java.lang.ThreadGroup类正如其名，可以统一管理整个线程组中的线程，您可以使用以下方式来产生线程组，而且一并指定其线程组：
ThreadGroup threadGroup1 = new ThreadGroup("group1");
ThreadGroup threadGroup2 = new ThreadGroup("group2");
Thread thread1 =
new Thread(threadGroup1, "group1's member");
Thread thread2 =
new Thread(threadGroup2, "group2's member");
ThreadGroup中的某些方法，可以对所有的线程产生作用，例如interrupt()方法可以interrupt线程组中所有的线程，setMaxPriority()方法可以设置线程组中线程所能拥有的最高优先权(本来就拥有更高优先权的线程不受影响)。
如果您想要一次获得线程组中所有的线程来进行某种操作，可以使用enumerate()方法，例如：
Thread[] threads = new Thread[threadGroup1.activeCount()];
threadGroup1.enumerate(threads);
activeCount()方法获得线程组中正在运行的线程数量，enumerate()方法要传入一个Thread数组，它将线程对象设置到每个数组字段中，然后就可以通过数组索引来操作这些线程。
ThreadGroup中有一个uncaughtException()方法。当线程组中某个线程发生Unchecked exception异常时，由执行环境调用此方法进行相关处理，如果有必要，您可以重新定义此方法，直接使用范例ThreadGroupDemo.java来示范如何实现。
范例ThreadGroupDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class ThreadGroupDemo {
public static void main(String[] args) {
ThreadGroup threadGroup1 =
// 这是匿名类写法
new ThreadGroup("group1") {
// 继承ThreadGroup并重新定义以下方法
// 在线程成员抛出unchecked exception
// 会执行此方法
public void uncaughtException(Thread t, Throwable e) {
System.out.println(t.getName() + ": "
+ e.getMessage());
}
};
// 这是匿名类写法
Thread thread1 =
// 这个线程是threadGroup1的一员
new Thread(threadGroup1,
new Runnable() {
public void run() {
// 抛出unchecked异常
throw new RuntimeException("测试异常");
}
});
thread1.start();
}
}
在uncaughtException()方法的参数中，第一个参数可以获得发生异常的线程实例，而第二个参数可以获得异常对象，范例中显示了线程的名称及异常信息，结果如下所示：
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。