前些天由于用到多线程处理，所以想到线程池，搜集了网上的一些资料，再分析改进一下，有了下面的东西。
首先是个读取配置文件的类：
1
package org.ofbiz.smsSend;
2
import java.io.File;
3
import java.io.FileInputStream;
4
import java.io.FileNotFoundException;
5
import java.io.FileOutputStream;
6
import java.io.IOException;
7
import java.util.Properties;
8
9
/** *//**
10
* @author zxub 2005-11-11 16:44:55
11
*/
12
13
public class UtilProperties
14
{
15
16
//设置默认的配置文件路径
17
private String fileName = System.getProperty("user.dir")
18
+ "/base/config.properties";
19
private Properties prop;
20
private FileInputStream in;
21
private FileOutputStream out;
22
23
/** *//**
24
* 自定义配置文件路径
25
* @param fileName
26
*/
27
public UtilProperties(String filePath)
28
{
29
this.fileName = System.getProperty("user.dir")+filePath;
30
getFile();
31
}
32
33
public UtilProperties()
34
{
35
getFile();
36
}
37
38
/** *//**
39
* 获取配置文件
40
*/
41
private void getFile()
42
{
43
File file = new File(this.fileName);
44
try
45
{
46
in = new FileInputStream(file);
47
prop = new Properties();
48
// 载入文件
49
prop.load(in);
50
in.close();
51
}
52
catch (FileNotFoundException e)
53
{
54
System.err.println("配置文件config.properties找不到！！");
55
}
56
catch (IOException e)
57
{
58
System.err.println("读取配置文件config.properties错误！！");
59
}
60
}
61
62
/** *//**
63
* 列出所有的配置文件内容
64
*/
65
public void list()
66
{
67
prop.list(System.out);
68
}
69
70
/** *//**
71
* 指定配置项名称，返回配置值
72
*
73
* @param itemName
74
* String
75
* @return String
76
*/
77
78
public String getValue(String itemName)
79
{
80
81
return prop.getProperty(itemName);
82
83
}
84
85
/** *//**
86
* 设置配置项名称及其值
87
*
88
* @param itemName
89
* String
90
* @param value
91
* String
92
*/
93
94
public void setValue(String itemName, String value)
95
{
96
prop.setProperty(itemName, value);
97
}
98
99
/** *//**
100
* 保存配置文件，指定文件名和抬头描述
101
*
102
* @param fileName
103
* String
104
* @param description
105
* String
106
* @throws Exception
107
*/
108
public void saveFile()
109
{
110
try
111
{
112
File f = new File(this.fileName);
113
out = new FileOutputStream(f);
114
prop.store(out, "");
115
out.close();
116
}
117
catch (FileNotFoundException e)
118
{
119
e.printStackTrace();
120
}
121
catch (IOException e)
122
{
123
System.err.println("配置文件config.properties写入错误！！");
124
}
125
126
}
127
128
/** *//**
129
* 删除一个属性
130
*
131
* @param value
132
* String
133
*/
134
135
public void deleteValue(String value)
136
{
137
prop.remove(value);
138
}
139
140
public void changeFile(String filePath)
141
{
142
this.fileName = System.getProperty("user.dir")+filePath;
143
getFile();
144
}
145
146
147
public static void main(String[] args)
148
{
149
UtilProperties up = new UtilProperties();
150
up.list();
151
up.changeFile("/logs/config.properties");
152
up.list();
153
System.out.println("\n"+up.getValue("tmpSavePath"));
154
}
155
156
}
157
接着，是要做事的类，我写了一个接口，只有一个方法doWork()，在线程池中，一旦一个线程获得一个工作任务，线程就会调用工作任务的doWork()方法。
package org.ofbiz.smsSend;
public interface Work
{
public abstract void doWork();
}
然后，就是主要的线程池类了：
1
/** *//**
2
* @author zxub 2005-12-3 19:44:33
3
*/
4
package org.ofbiz.smsSend;
5
6
import java.util.ArrayList;
7
import java.util.Iterator;
8
import java.util.LinkedList;
9
import java.util.Timer;
10
11
public class ThreadPool
12
{
13
private static final UtilProperties utilProp = new UtilProperties();
14
private static int minPools = Integer.parseInt(utilProp
15
.getValue("minPools"));
16
private static int maxPools = Integer.parseInt(utilProp
17
.getValue("maxPools"));
18
private static int checkThreadPeriod = Integer.parseInt(utilProp
19
.getValue("checkThreadPeriod")) * 60 * 1000;
20
private static ArrayList workThreadList; // 工作线程列表，保存所有的线程
21
private static LinkedList taskList = null; // 工作任务列表，保存将要执行的工作任务
22
private static int totalThread = 0; // 总线程数
23
private static int freeThreadCount = 0; // 未被使用的线程数目
24
private java.util.Timer timer = null; // 定时器
25
private static Object o = new Object();
26
27
private static ThreadPool pool=new ThreadPool();
28
29
public static void setMinPools(int minPools)
30
{
31
ThreadPool.minPools = minPools;
32
}
33
34
public static void setMaxPools(int maxPools)
35
{
36
ThreadPool.maxPools = maxPools;
37
}
38
39
public static void setCheckThreadPeriod(int checkThreadPeriod)
40
{
41
ThreadPool.checkThreadPeriod = checkThreadPeriod;
42
}
43
44
private ThreadPool()
45
{
46
workThreadList = new ArrayList();
47
taskList = new LinkedList();
48
//初始化线程池
49
for (int i = 0; i < ThreadPool.minPools; i++)
50
{
51
WorkerThread temp = new WorkerThread();
52
totalThread = totalThread + 1;
53
workThreadList.add(temp);
54
temp.start();
55
try
56
{
57
Thread.sleep(100);
58
}
59
catch (Exception e)
60
{
61
}
62
}
63
timer = new Timer(true); // 启动定时器
64
timer.schedule(new CheckThreadTask(this), 0, checkThreadPeriod);
65
}
66
67
public static ThreadPool getInstance()
68
{
69
return pool;
70
}
71
72
public synchronized void run(Work work)
73
{
74
if (freeThreadCount == 0)
75
{
76
if (totalThread < maxPools)
77
{
78
WorkerThread temp = new WorkerThread();
79
totalThread = totalThread + 1;
80
workThreadList.add(temp);
81
temp.start();
82
synchronized (taskList)
83
{
84
taskList.add(work);
85
taskList.notify();
86
}
87
}
88
else
89
{
90
while (freeThreadCount == 0)
91
{
92
try
93
{
94
Thread.sleep(200);
95
}
96
catch (InterruptedException e)
97
{
98
}
99
}
100
synchronized (taskList)
101
{
102
taskList.add(work);
103
taskList.notify();
104
}
105
}
106
}
107
else
108
{
109
synchronized (taskList)
110
{
111
taskList.add(work);
112
taskList.notify();
113
}
114
}
115
}
116
117
/** *//**
118
* 检查工作线程列表，将非活动状态的线程换成活动状态的线程，保证线程池中的线程可用
119
*
120
*/
121
public synchronized void checkAllThreads()
122
{
123
124
Iterator threadIterator = workThreadList.iterator();
125
126
while (threadIterator.hasNext())
127
{ // 逐个遍厉
128
WorkerThread workThread = (WorkerThread) threadIterator.next();
129
130
if (!(workThread.isAlive()))
131
{
132
// 如果处在非活动状态时
133
workThread = new WorkerThread(); // 重新生成1个线程
134
workThread.start(); // 启动
135
}
136
}
137
}
138
139
public static void printInfo()
140
{
141
System.out.println("minPools:" + minPools);
142
System.out.println("maxPools:" + maxPools);
143
System.out.println("checkThreadPeriod:" + checkThreadPeriod);
144
System.out.println("totalThread=" + totalThread);
145
System.out.println("workThreadList.size()=" + workThreadList.size());
146
}
147
148
/** *//**
149
* 线程池中的工作线程类，由工作线程执行我们要进行的操作
150
*/
151
class WorkerThread extends Thread
152
{
153
boolean running = true;
154
Work work;
155
156
public void run()
157
{
158
while (running)
159
{
160
synchronized (o)
161
{
162
freeThreadCount++; //一进来说明多了一个可用线程
163
}
164
synchronized (taskList)
165
{
166
while (taskList.size() == 0) //当工作任务列表为空时，等待
167
{
168
try
169
{
170
taskList.wait();
171
if (!running) return;
172
}
173
catch (InterruptedException e)
174
{
175
}
176
}
177
synchronized (o)
178
{
179
freeThreadCount--; //得到一个工作，可用线程要减1
180
}
181
work = (Work) taskList.removeLast(); //从任务列表处获得一个任务
182
if (work == null) return;
183
}
184
work.doWork();
185
}
186
}
187
}
188
}
189
定时器自动查失效的线程，用到的方法如下：
1
package org.ofbiz.smsSend;
2
3
import java.util.TimerTask;
4
5
public class CheckThreadTask extends TimerTask
6
{
7
private static boolean isRunning = false;
8
private ThreadPool pool;
9
10
public CheckThreadTask(ThreadPool pool)
11
{
12
this.pool = pool;
13
}
14
15
public void run()
16
{
17
if (!isRunning)
18
{
19
isRunning = true;
20
pool.checkAllThreads();
21
isRunning = false;
22
}
23
}
24
}
25
最后，配置文件的内容如下
1
#----------------线程池配置信息-----------------
2
#
3
#线程池最小线程
4
minPools=10
5
#线程池最大线程
6
maxPools=100
7
#检查线程池中线程的周期(分钟)
8
checkThreadPeriod=5 ok，要用的时候，调用方法如下：
1
ThreadPool.getInstance().run(new (实现了work接口的类));本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
