多线程实例片段

/**
*
*
* 下面是部分code， 全部code 见附件
*
*/
package com.task;

/**
* 线程模板 实现线程的暂停和恢复
*
* 全部code 见附件
*
*/
public abstract class TemplateThread implements Runnable {
/**
* 线程状态 默认是false，即允许状态
*/
private boolean pause;

@Override
public void run() {
try {
while (!Thread.interrupted()) {
work();

// 检测当前线程是否暂停
synchronized (this) {
if (pause) {
this.wait();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}

/**
* 暂停
*/
public synchronized void pause() {
pause = true;
}

/**
* 恢复
*/
public synchronized void resume() {
pause = false;
this.notifyAll();
}

/**
* @return 当前状态
*/
public boolean isPause() {
return pause;
}

/**
* 线程工作内容
*
* @throws InterruptedException
*/
public abstract void work() throws InterruptedException;

}


package com.task;

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;

/**
* 管理任务收集器和处理器
*
*
*
*/
public class TaskManager extends TemplateThread {
// task queue
private BlockingQueue<Task> taskQueue;
// gatherer
private TaskGather gatherer;
// worker
private PriorityQueue<TaskHandler> workers;
private Queue<TaskHandler> noWorkers;
// executor
private ExecutorService executor;

public TaskManager(int maxTaskSize, ExecutorService executor) {
this.taskQueue = new ArrayBlockingQueue<Task>(maxTaskSize);
this.workers = new PriorityQueue<TaskHandler>(100);
this.noWorkers = new LinkedList<TaskHandler>();

this.gatherer = new TaskGather(taskQueue);

this.executor = executor;

addGenerator();
addHandler();
}

@Override
public void work() throws InterruptedException {
TimeUnit.SECONDS.sleep(10);
adjustHandlers();
printNoWorker();
}

private void adjustHandlers() throws InterruptedException {
if (taskQueue.size() > 0) {
if (0 == workers.size() || taskQueue.size() / workers.size() < 1) {
addHandler();
}
if (taskQueue.size() / workers.size() >= 1
&& taskQueue.size() / workers.size() < 2) {
TaskHandler taskHandler = noWorkers.poll();
if (null == taskHandler) {
addHandler();
} else {
taskHandler.resume();
workers.offer(taskHandler);
}
}// hire a new handler
else if (taskQueue.size() / workers.size() >= 2) {
addHandler();
} else {
TaskHandler taskHandler = workers.poll();
if (null != taskHandler) {

taskHandler.pause();
noWorkers.offer(taskHandler);
}
}
} else {
TaskHandler taskHandler = null;
while (null != (taskHandler = workers.poll())) {
taskHandler.pause();
noWorkers.offer(taskHandler);

}
}

if (gatherer.getCount() > 100) {
gatherer.pause();
}
}

private void addGenerator() {
executor.execute(gatherer);
}

private void addHandler() {
TaskHandler taskHandler = new TaskHandler(taskQueue);
executor.execute(taskHandler);
workers.offer(taskHandler);

}

private void printNoWorker() {
System.out
.println("====================================================");
for (TaskHandler taskHandler : noWorkers) {
System.out.println("manager" + taskHandler);
}
System.out
.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++");
}
}