138-给线程池增加自动扩充线程数量,以及闲时自动回收的功能
public class SimpleThreadPool extends Thread {
// 最小线程数量
private int min;
// 活跃线程数量
private int active;
// 最大线程数量
private int max;
// 传参线程池大小(当前线程池中线程的数量)
private int size;
// 线程队列的大小
private final int queueSize;
// 拒绝策略
private final DiscardPolicy discardPolicy;
// 线程池是否被销毁
private volatile boolean destroy = false;
// 默认线程队列的大小
private static final int DEFAULT_TASK_QUEUE_SIZE = 2000;
// 默认拒绝策略-抛出异常
public static final DiscardPolicy DEFAULT_DISCARD_POLICY = () -> {
throw new DiscardException("Discard This Task.");
};
// 线程名自增序号
private static AtomicInteger sequence = new AtomicInteger();
// 线程名前缀
private static final String THREAD_PREFIX = "SIMPLE_THREAD_POOL-";
// 线程组
private static final ThreadGroup GROUP = new ThreadGroup("Pool_Group");
// 任务队列
private static final LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();
// 线程队列
private static final List<WorkerTask> THREAD_QUEUE = new ArrayList<>();
public SimpleThreadPool() {
this(4, 8, 12, DEFAULT_TASK_QUEUE_SIZE, DEFAULT_DISCARD_POLICY);
}
/**
* 构造方法
* @param min 最小线程数量
* @param active 活跃线程数量
* @param max 最大线程数量
* @param queueSize 线程队列的大小
* @param discardPolicy 拒绝策略
*/
public SimpleThreadPool(int min, int active, int max, int queueSize, DiscardPolicy discardPolicy) {
this.min = min;
this.active = active;
this.max = max;
this.queueSize = queueSize;
this.discardPolicy = discardPolicy;
init();
}
@Override
public void run() {
while (!destroy) {
System.out.printf("Pool#Min:%d,Active:%d,Max:%d,Current:%d,QueueSize:%d\n",
this.min, this.active, this.max, this.size, TASK_QUEUE.size());
try {
Thread.sleep(5_000L);
// 任务队列数量过大,线程队列的数量扩充到active
if (size < active && active < TASK_QUEUE.size()) {
IntStream.range(size, active).forEach(i -> createWorkTask());
size = active;
System.out.println("The Pool incremented to active.");
}
// 任务队列数量过大,线程队列的数量扩充到max
else if (size < max && max < TASK_QUEUE.size()) {
IntStream.range(active, max).forEach(i -> createWorkTask());
size = max;
System.out.println("The Pool incremented to max.");
}
// 防止新插入任务队列的任务使用线程队列中的线程执行任务。
synchronized (THREAD_QUEUE) {
// 任务队列数量为空,线程队列的数量减少到active
if (size > active && TASK_QUEUE.isEmpty()) {
System.out.println("=========Reduce=========");
int releaseSize = size - active;
for (Iterator<WorkerTask> it = THREAD_QUEUE.iterator(); it.hasNext(); ) {
if (releaseSize <= 0) {
break;
}
WorkerTask task = it.next();
task.interrupt();
task.close();
it.remove();
releaseSize--;
}
size = active;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void init() {
IntStream.range(0, this.min).forEach(i -> createWorkTask());
this.size = this.min;
this.start();
}
private void createWorkTask() {
WorkerTask task = new WorkerTask(GROUP, THREAD_PREFIX + (sequence.getAndIncrement()));
task.start();
THREAD_QUEUE.add(task);
}
// 提交任务
public void submit(Runnable runnable) {
// 如果线程池被销毁,不能添加任务到任务队列
if (destroy) {
throw new IllegalThreadStateException("The thread pool already destroy and not allow submit task.");
}
synchronized (TASK_QUEUE) {
// 任务队列数量超过阈值,则执行拒绝策略
if (TASK_QUEUE.size() > queueSize) {
discardPolicy.discard();
}
TASK_QUEUE.addLast(runnable);
TASK_QUEUE.notifyAll();
}
}
// 关闭线程池中的线程
public void shutdown() throws InterruptedException {
// 当任务队列还有任务,则稍微等待。
while (!TASK_QUEUE.isEmpty()) {
Thread.sleep(50);
}
// 判断线程中有没有正在运行的任务
synchronized (THREAD_QUEUE) {
int initVal = THREAD_QUEUE.size();
while (initVal > 0) {
for (WorkerTask task : THREAD_QUEUE) {
if (task.getTaskState() == TaskState.BLOCKED) {
task.interrupt();
task.close();
initVal--;
} else {
Thread.sleep(10);
}
}
}
}
System.out.println("Group active count is " + GROUP.activeCount());
this.destroy = true;
System.out.println("The thread pool disposed.");
}
// 封装任务类
private static class WorkerTask extends Thread {
private volatile TaskState taskState = TaskState.FREE;
public TaskState getTaskState() {
return this.taskState;
}
public WorkerTask(ThreadGroup group, String name) {
super(group, name);
}
@Override
public void run() {
OUTER:
while (this.taskState != TaskState.DEAD) {
Runnable runnable;
synchronized (TASK_QUEUE) {
// 任务队列为空,则进入阻塞状态
while (TASK_QUEUE.isEmpty()) {
try {
this.taskState = TaskState.BLOCKED;
TASK_QUEUE.wait();
} catch (InterruptedException e) {
System.out.println("Closed.");
break OUTER;
}
}
// 任务队列不为空,取出任务
runnable = TASK_QUEUE.removeFirst();
}
// 任务不为空,则执行任务
if (runnable != null) {
this.taskState = TaskState.RUNNING;
runnable.run();
this.taskState = TaskState.FREE;
}
}
}
public void close() {
this.taskState = TaskState.DEAD;
}
}
// 线程状态
private enum TaskState {
FREE, RUNNING, BLOCKED, DEAD
}
// 拒绝策略
public interface DiscardPolicy {
void discard() throws DiscardException;
}
// 拒绝策略异常
public static class DiscardException extends RuntimeException {
public DiscardException(String message) {
super(message);
}
}
}
public static void main(String[] args) throws InterruptedException {
SimpleThreadPool threadPool = new SimpleThreadPool();
IntStream.rangeClosed(1, 40).forEach(i -> {
threadPool.submit(() -> {
System.out.printf("The runnable %d be serviced by %s start.\n", i, Thread.currentThread().getName());
Thread.sleep(3_000L);
System.out.printf("The runnable %d be serviced by %s finished.\n", i, Thread.currentThread().getName());
});
});
Thread.sleep(30_000L);
threadPool.shutdown();// 关闭线程池中的线程
}
升级改造:
批次处理任务
处理完成后立即返回结果
立即shutdown,并返回未执行完成的
List<Runnable>
转载请注明来源,欢迎对文章中的引用来源进行考证,欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论,也可以邮件至 tuyrk@qq.com
文章标题:138-给线程池增加自动扩充线程数量,以及闲时自动回收的功能
文章字数:994
本文作者:神秘的小岛岛
发布时间:2019-12-11, 00:26:01
最后更新:2019-12-14, 01:00:32
原始链接:https://www.tuyrk.cn/wang-thread/138-thread-pool-expan/版权声明: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。