线程池在现在的系统和框架中十分常见。明白线程池的思想原理,不仅对学习线程池有
很大的帮助。对理解一些系统的线程池实现也有很大的帮助。下面是我自己简单实现的一
个线程池。用以对线程的简单理解。
线程的实现原理很简单:
> 线程池对象包含以下组件:工作者队列,Job队列;
> 用户通过线程池对象添加删除工作者,线程池对象维持工作者对象这个池
和工作者的实际工作;
> 工作者池中的线程在用户没用明确关闭前不断的从Job队列拿取job执行job。
好了,一切看代码:
1. 面向接口编程,首先创建ThreadPool接口:
public interface ThreadPool<Job extends Runnable> {
void execute(Job job);
void shutdown();
void addWorkers(int num);
void removeWorkers(int num);
int getJobSize();
}
2. 实现ThreadPool接口:
public class DefaultThreadPool<Job extends Runnable> implements ThreadPool<Job>{
private static final int MAX_WORKER_NUMBER = 10;
private static final int DEFAULT_WORKER_NUMBER = 5;
private static final int MIN_WORKER_NUMBER = 1;
private final LinkedList<Job> jobs = new LinkedList<>();
private final List<Worker> workers = Collections.synchronizedList(new ArrayList<Worker>());
private int workerNum = 5;
private AtomicLong threadNum = new AtomicLong();
public DefaultThreadPool() {
initWorkers(DEFAULT_WORKER_NUMBER);
}
public DefaultThreadPool(int num){
workerNum = num > MAX_WORKER_NUMBER?MAX_WORKER_NUMBER:num < MIN_WORKER_NUMBER?MIN_WORKER_NUMBER:num;
initWorkers(workerNum);
}
@Override
public void execute(Job job) {
if(job==null)
throw new NullPointerException();
synchronized (jobs) {
jobs.addLast(job);
jobs.notify();
}
}
@Override
public void shutdown() {
for (int i = 0; i < workers.size(); i++) {
Worker worker = workers.get(i);
worker.shutdown();
}
}
@Override
public void addWorkers(int num) {
synchronized (jobs) {
if(num+this.workerNum>MAX_WORKER_NUMBER)
num = MAX_WORKER_NUMBER - workerNum;
initWorkers(num);
workerNum+=num;
}
}
@Override
public void removeWorkers(int num) {
synchronized (jobs) {
if(num>=workerNum)
throw new IllegalArgumentException("beyond worknum");
int count = 0;
while(count<num){
Worker worker = workers.get(count);
if(workers.remove(worker)){
worker.shutdown();
count++;
}
}
this.workerNum-=num;
}
}
@Override
public int getJobSize() {
return this.workerNum;
}
private void initWorkers(int num){
for (int i = 0; i < num; i++) {
Worker worker = new Worker();
workers.add(worker);
Thread thread = new Thread(worker, "ThreadPool-Worker-"+threadNum.getAndIncrement());
thread.start();
}
}
class Worker implements Runnable{
private volatile boolean running = true;
@Override
public void run() {
while(running){
Job job = null;
synchronized (jobs) {
while(jobs.isEmpty()){
try {
jobs.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
}
job = jobs.removeFirst();
}
if(job!=null){
try {
job.run();
} catch (Exception e) {
}
}
}
}
public void shutdown(){
running = false;
}
}
}
3. 测试代码如下:
public class ThisTest {
public static void main(String[] args) {
ThreadPool<Runnable> pool = new DefaultThreadPool<>(2);
for (int i = 0; i < 100; i++) {
pool.execute(new countThread());
}
}
static class countThread implements Runnable{
private static volatile Integer count = 0;
private static Object object = new Object();
@Override
public void run() {
synchronized(object){
count++;
System.err.println(count);
}
}
}
}