SimpleThreadPool给线程池增加自动扩充线程数量,以及闲时自动回收的功能
给线程池增加自动扩充线程数量,以及闲时自动回收的功能
package com.dwz.concurrency.chapter13; import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List; public class SimpleThreadPool4 extends Thread {
private static int size;
private final int queueSize;
private final static int DEFAULT_TASK_QUEUE_SIZE = 2000;
private static volatile int seq = 0;
private final static String THREAD_PREFIX = "SIMPLE_THREAD_POOL-";
private final static ThreadGroup GROUP = new ThreadGroup("Pool_Group");
private final static LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();
private final static List<WorkerTask> THREAD_QUEUE = new ArrayList<>();
private final DiscardPolicy discardPolicy;
private final static DiscardPolicy DEFAULT_DISCARD_POLICY = () -> {
throw new DiscardException("Discard this task.");
};
private volatile boolean destroy = false;
private int min;
private int max;
private int active; public SimpleThreadPool4() {
this(4, 8, 12, DEFAULT_TASK_QUEUE_SIZE, DEFAULT_DISCARD_POLICY);
} public SimpleThreadPool4(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();
} private void init() {
for (int i = 0; i < this.min; i++) {
createWorkTask();
}
this.size = min;
this.start();
} public void submit(Runnable runnable) {
if (destroy) {
throw new IllegalStateException("The thread pool already destroy and not allow submit task.");
}
synchronized (TASK_QUEUE) {
if (TASK_QUEUE.size() >= this.queueSize) {
discardPolicy.discard();
}
TASK_QUEUE.addLast(runnable);
TASK_QUEUE.notifyAll();
}
} @Override
public void run() {
while (!destroy) {
System.out.printf("Pool#Min:%d,Active:%d,Max:%d,Current:%d,QueueSize:%d,ThreadQueueSize::%d\n",
this.min, this.active, this.max, this.size, TASK_QUEUE.size(), THREAD_QUEUE.size());
try {
Thread.sleep(5_000L);
if(TASK_QUEUE.size() > this.active && this.size < this.active) {
for(int i = this.size; i < this.active; i++) {
createWorkTask();
}
System.err.printf("The pool incremented to active. currentSize:%d\n", this.size);
this.size = this.active;
} else if(TASK_QUEUE.size() > this.max && this.size < this.max) {
for(int i = this.size; i < this.max; i++) {
createWorkTask();
}
System.err.printf("The pool incremented to max currentSize:%d\n", this.size);
this.size = this.max;
} if(TASK_QUEUE.isEmpty() && this.size > this.active) {
System.out.println("===============Reduce===============");
synchronized (THREAD_QUEUE) {
int releaseSize = this.size - this.active;
for(Iterator<WorkerTask> it = THREAD_QUEUE.iterator(); it.hasNext();) {
if(releaseSize <= 0) {
break;
}
WorkerTask task = it.next();
task.close();
task.interrupt();
it.remove();
releaseSize--;
}
this.size = this.active;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} private void createWorkTask() {
WorkerTask task = new WorkerTask(GROUP, THREAD_PREFIX + (seq++));
task.start();
THREAD_QUEUE.add(task);
} 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);
}
}
}
}
this.destroy = true;
System.out.println("The thread pool disposed.");
System.err.println("THREAD_QUEUE size is: " + THREAD_QUEUE.size());
System.out.println("GROUP.activeCount() is: " + GROUP.activeCount());
} public int getSize() {
return size;
} public int getQueueSize() {
return queueSize;
} public int getMin() {
return min;
} public int getMax() {
return max;
} public int getActive() {
return active;
} public boolean isDestroy() {
return destroy;
} private enum TaskState {
FREE, RUNNING, BLOCKED, DEAD
} public static class DiscardException extends RuntimeException { public DiscardException(String message) {
super(message);
}
} public interface DiscardPolicy {
void discard() throws DiscardException;
} private static class WorkerTask extends Thread {
private volatile TaskState taskState = TaskState.FREE; public WorkerTask(ThreadGroup group, String name) {
super(group, name);
} public TaskState getTaskState() {
return this.taskState;
} @Override
public void run() {
OUTER: while (this.taskState != TaskState.DEAD) {
Runnable runnable = null;
synchronized (TASK_QUEUE) {
while (TASK_QUEUE.isEmpty()) {
try {
this.taskState = TaskState.BLOCKED;
TASK_QUEUE.wait();
} catch (InterruptedException e) {
e.printStackTrace();
System.err.println("closed.");
// 线程被打断回到OUTER位置
break OUTER;
}
}
runnable = TASK_QUEUE.removeFirst();
} if (runnable != null) {
System.out.println("runnable into...");
this.taskState = TaskState.RUNNING;
runnable.run();
this.taskState = TaskState.FREE;
}
}
} public void close() {
this.taskState = TaskState.DEAD;
}
} public static void main(String[] args) throws InterruptedException {
SimpleThreadPool4 threadPool = new SimpleThreadPool4();
for (int i = 0; i < 100; i++) {
threadPool.submit(() -> {
System.out.println("The runnable be serviced by " + Thread.currentThread() + " start.");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("The runnable be serviced by " + Thread.currentThread() + " finished.");
});
}
}
}
SimpleThreadPool给线程池增加自动扩充线程数量,以及闲时自动回收的功能的更多相关文章
- SimpleThreadPool给线程池增加拒绝策略和停止方法
给线程池增加拒绝策略和停止方法 package com.dwz.concurrency.chapter13; import java.util.ArrayList; import java.util. ...
- 线程池如何复用一个线程-- ThreadPoolExecutor的实现(未完)
任务是一组逻辑工作单元,而线程则是使任务异步执行的机制.在Java中,Runnable对象代表一个任务,Thread对象负责创建一个线程执行这个任务. 前提:1. 程序需要处理大量任务 2. 任务的执 ...
- 使用Callable接口创建线程和使用线程池的方式创建线程
1.使用Callable接口的方式实现多线程,这是JDK5.0新增的一种创建多线程的方法 package com.baozi.java2; import java.util.concurrent.Ca ...
- 发一个可伸缩线程池大小的python线程池。已通过测试。
发一个可伸缩线程池大小的线程池. 当任务不多时候,不开那么多线程,当任务多的时候开更多线程.当长时间没任务时候,将线程数量减小到一定数量. java的Threadpoolexcutor可以这样,py的 ...
- 线程池系列一:线程池作用及Executors方法讲解
线程池的作用: 线程池作用就是限制系统中执行线程的数量. 根据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果:少了浪费了系统资源,多了造成系统拥挤效率不高.用线程池控制线程数量 ...
- 线程池;java的线程池的实现原理;适用于频繁互动(如电商网站)
线程池是一种多线程处理形式,处理过程中将任务加入到队列,然后在创建线程后自己主动启动这些任务.线程池线程都是后台线程.每一个线程都使用默认的堆栈大小,以默认的优先级执行.并处于多线程单元中. 假设某个 ...
- java多线程系类:JUC线程池:05之线程池原理(四)(转)
概要 本章介绍线程池的拒绝策略.内容包括:拒绝策略介绍拒绝策略对比和示例 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3512947.html 拒绝策略 ...
- java多线程系类:JUC线程池:03之线程池原理(二)(转)
概要 在前面一章"Java多线程系列--"JUC线程池"02之 线程池原理(一)"中介绍了线程池的数据结构,本章会通过分析线程池的源码,对线程池进行说明.内容包 ...
- java多线程系类:JUC线程池:04之线程池原理(三)(转)
转载请注明出处:http://www.cnblogs.com/skywang12345/p/3509960.html 本章介绍线程池的生命周期.在"Java多线程系列--"基础篇& ...
随机推荐
- <<C++ Primer>> 第 7 章 类
术语表 第 7 章 类 抽象数据类型(abstract data type): 封装(隐藏)了实现细节的数据结构. 访问说明符(access specifier): 包括关键字 public 和 ...
- liunx忘记用户密码
1.vim /etc/my.cnf [mysqld] skip-grant-tables ##追加此行,跳过权限表, 2.重启mysql systemctl restart mysqld 3.mysq ...
- BM求线性递推模板(杜教版)
BM求线性递推模板(杜教版) BM求线性递推是最近了解到的一个黑科技 如果一个数列.其能够通过线性递推而来 例如使用矩阵快速幂优化的 DP 大概都可以丢进去 则使用 BM 即可得到任意 N 项的数列元 ...
- 数据结构(四) 图(Graph)
在图形结构中,结点之间的关系可以是任意的. 一.图 图由定点(vertex)和边(edge)两个有限集合组成: Graph=(V,R) V是定点集,R={E},E是边集. 有向图(directed n ...
- springboot(十七)-使用Docker部署springboot项目
Docker 技术发展为微服务落地提供了更加便利的环境,使用 Docker 部署 Spring Boot 其实非常简单,这篇文章我们就来简单学习下. 首先构建一个简单的 Spring Boot 项目, ...
- performance面板使用,以及解决动画卡顿
https://googlechrome.github.io/devtools-samples/jank// 官方案例 https://juejin.im/post/5b65105f518825 ...
- react 基础语法使用
刚开始不久react,在菜鸟上及其他前辈网站上学习,下面开始我的自学笔记. 包括: 渲染元素 组件(函数方法定义.es6 class定义) 事件处理 条件渲染 列表 下面代码部分将不会再写html部分 ...
- Summer training round2 #4 (Training #20)
A!:UESTC1752 B!:找区间内L到R之间内的数的个数 权值分块加莫队 C!:给你一个哈斯图 去掉其中的几条边 要求输出字典序最大的拓扑排序:线段树模拟拓扑排序 D!:要求你找到最短路树并输 ...
- 构建一个highcharts
示例:http://www.helloweba.com/demo/highcharts/line.html <!doctype html> <html lang="en&q ...
- chown -R lyd usbsend
chown -R lyd usbsend chown -R lyd usbsend chown -R lyd usbsend 某一个目录下所有文件授权给lyd