线程一般是并发包里面的东西，我们重新写一个线程是没有必要的，我们手写线程是是为了掌握他的原理等。
线程是非常重的：
线程池为什么要有它：
线程创建要开辟虚拟机栈，释放线程要垃圾回收的。
server端要并发访问数据库的，server要处理客户端的很多的请求。可能就是1ms的请求，但是创建和终止这个线程不止是1ms。
优化：服务器启动有线程池放着若干个线程。
-----
线程池的概念：
1.任务队列，提交100个任务，但是线程池线程只有10个。
2.任务实在是太多了就要有拒绝策略(抛出异常，直接丢弃，阻塞，放在临时队列-这个是有很多的队列的)。
3.初始化值init(min),初始线程池大小。
4.active经常活跃的线程池的线程大小。
5.max线程池线程的最大个数。
init<=active<=max。
quartz:定时任务。
异步执行，给我一个Future。
-----------35-------------
代码：
package chapter13;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class SimpleThreadPoolMy {
private final int size;
private final static int DEFAULT_SIZE = 10;
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 List<WorkerTask> THREAD_QUEUE = new ArrayList<>();
/**
* 第九步：任务队列装runnable的
*/
private final static LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();
// 第一步写默认的
public SimpleThreadPoolMy() {
this(DEFAULT_SIZE);
}
// 第二步写重写的方法
public SimpleThreadPoolMy(int size) {
this.size = size;
init();
}
//第十一步： 初始化
private void init() {
for (int i = 0; i < size; i++) {
createWorkTask();
}
}
// 第十步：创建任务加入到队列
private void createWorkTask() {
WorkerTask task = new WorkerTask(GROUP, THREAD_PREFIX + (seq++));
task.start();
THREAD_QUEUE.add(task);
}
// 第四步 枚举 定义线程的状态
private enum TaskState {
FREE, RUNNING, BLOCKEED, DEAD
}
// 第十二步：给任务
public void submit(Runnable runnable) {
synchronized (TASK_QUEUE) {//别的方法有读的操作，这里有写的操作，所以你要加锁的
TASK_QUEUE.addLast(runnable);
TASK_QUEUE.notifyAll();
}
}
/**
* 第三步：线程池里面的线程
*/
private static class WorkerTask extends Thread {//为什么定义为private呢就是为了不想让别人知道我是什么
private volatile TaskState taskState = TaskState.FREE;
// 第八步：调用thread的构造方法
public WorkerTask(ThreadGroup group, String name) {//构造方法，调用了Thread的构造
super(group, name);
}
// 第五步：获取当前的线程状态状态
public TaskState getTaskState() {
return this.taskState;
}
// 第六步：关闭
public void close() {
this.taskState = TaskState.DEAD;
}
// 第七步：写run方法 执行完不能挂掉
public void run() {//重写run方法保证执行完之后不能挂掉
OUTER:
while (this.taskState != TaskState.DEAD) {//当前的线程没有死掉
Runnable runnable;
synchronized (TASK_QUEUE) {//去任务队列调取任务
while (TASK_QUEUE.isEmpty()) {
try {
taskState = TaskState.BLOCKEED;
TASK_QUEUE.wait();//没有任务就释放锁，这个线程在TASK_QUEUE上等待 wait会被打断 打断的话就break出来
} catch (InterruptedException e) {
break OUTER;//https://blog.csdn.net/zhaoheng2017/article/details/78385973 被打断了就接着去调取任务
}
}
runnable = TASK_QUEUE.removeFirst();//队列 先进先出 任务队列只被消费一次 比如数据库线程池，取出来我执行连接就可以了
}
if (runnable != null) {
taskState = TaskState.RUNNING;
runnable.run();
taskState = TaskState.FREE;
}
}
}
}
}
目前：
测试下：
SimpleThreadPoolMy threadPool = new SimpleThreadPoolMy();
for (int i = 0; i < 40; i++) {
threadPool.submit(() -> {
System.out.println("The runnable be serviced by " + Thread.currentThread() + " start.");
try {
Thread.sleep(10_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("The runnable be serviced by " + Thread.currentThread() + " finished.");
});
}第一本笔记第五页。
-------------------------------------------------------36----------------------------------------------------------
一般来说线程池的任务队列是不能无限制的增大的。
拒绝策略和停止方法：
1.拒绝策略代码：
package one.chapter13;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class SimpleThreadPoolMyOne {
private final int size;
private final int queueSize;
private final static int DEFAULT_SIZE = 10;
private final static int DEFAULT_TASK_QUEUE_SIZE = 2000; //第一步设置拒绝策略
private static volatile int seq = 0;//线路迭代
private final static String THREAD_PREFIX = "MESSAGE_THREAD_POOL-";//采集线路名称标记
private final static ThreadGroup GROUP = new ThreadGroup("Pool_Group_CHANNEL");//采集组
private final static List<WorkerTask> THREAD_QUEUE = new ArrayList<>();//任务集合有几个线程
private final static LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();//工作队列去这里取做什么工作
private final DiscardPolicy discardPolicy;
public final static DiscardPolicy DEFAULT_DISCARD_POLICY = ()->{// 第六步：出问题默认抛出异常
throw new DiscardException("Discard this task");
};
public SimpleThreadPoolMyOne() {
this(DEFAULT_SIZE,DEFAULT_TASK_QUEUE_SIZE,DEFAULT_DISCARD_POLICY);
}
public SimpleThreadPoolMyOne(int size,int queueSize,DiscardPolicy discardPolicy) {
this.size = size;
this.queueSize = queueSize;// 第二步：自己赋值给任务队列要多大
this.discardPolicy = discardPolicy;
init();
}
private void init() {
for (int i = 0; i < size; i++) {
createWorkTask();
}
}
private void createWorkTask() {//创建10个线程
WorkerTask task = new WorkerTask(GROUP, THREAD_PREFIX + (seq++));
task.start();
THREAD_QUEUE.add(task);
}
private enum TaskState {
FREE, RUNNING, BLOCKED, DEAD
}
public static class DiscardException extends RuntimeException{// 第五步:异常
public DiscardException(String message){
super(message);
}
}
public interface DiscardPolicy{// 第四步：简单定义
void descard() throws DiscardException;
}
public void submit(Runnable runnable) {// 第三步：做手脚
synchronized (TASK_QUEUE) {//别的方法有读的操作，这里有写的操作，所以你要加锁的
if(TASK_QUEUE.size()>queueSize){
discardPolicy.descard();
}
TASK_QUEUE.addLast(runnable);
TASK_QUEUE.notifyAll();
}
}
/**
* Thread in ThreadPool
*/
private static class WorkerTask extends Thread {//为什么定义为private呢就是为了不想让别人知道我是什么
private volatile TaskState taskState = TaskState.FREE;//每个任务都有自己的taskState
public WorkerTask(ThreadGroup group, String name) {//构造方法，调用了Thread的构造
super(group, name);
}
public TaskState getTaskState() {
return this.taskState;
}
public void close() {
this.taskState = TaskState.DEAD;
}
public void run() { //重写run方法保证执行完之后不能挂掉
OUTER:
while (this.taskState != TaskState.DEAD) { //当前的线程没有死掉 线程调用的方法都是while
Runnable runnable;
synchronized (TASK_QUEUE) { //去任务队列调取任务
while (TASK_QUEUE.isEmpty()) {
try {
this.taskState = TaskState.BLOCKED;
TASK_QUEUE.wait(); //没有任务就释放锁，这个线程在TASK_QUEUE上等待 wait会被打断 打断的话就break出来
} catch (InterruptedException e) {
break OUTER; //https://blog.csdn.net/zhaoheng2017/article/details/78385973 被打断了就接着去调取任务
}
}
runnable = TASK_QUEUE.removeFirst();//队列 先进先出 任务队列只被消费一次 比如数据库线程池，取出来我执行连接就可以了
}
if (runnable != null) { //任务不加锁去并行的
this.taskState = TaskState.RUNNING;
runnable.run();
this.taskState = TaskState.FREE;
}
}
}
}
}
测试拒绝策略。
2.停止线程池：
代码：
中断：https://www.cnblogs.com/JackPn/p/9426518.html
package chapter13;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class SimpleThreadPoolStop {
private final int size;
private final int queueSize;
private final static int DEFAULT_SIZE = 10;
private final static int DEFAULT_TASK_QUEUE_SIZE = 2000;
private static volatile int seq = 0;//线路迭代
private final static String THREAD_PREFIX = "MESSAGE_THREAD_POOL-";//采集线路名称标记
private final static ThreadGroup GROUP = new ThreadGroup("Pool_Group_CHANNEL");//采集组
private final static List<WorkerTask> THREAD_QUEUE = new ArrayList<>();//任务集合有几个线程
private final static LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();//工作队列去这里取做什么工作
private final SimpleThreadPoolMyOne.DiscardPolicy discardPolicy;
private volatile boolean destory = false;
public final static SimpleThreadPoolMyOne.DiscardPolicy DEFAULT_DISCARD_POLICY = ()->{
throw new SimpleThreadPoolMyOne.DiscardException("Discard this task");
};
public SimpleThreadPoolStop() {
this(DEFAULT_SIZE,DEFAULT_TASK_QUEUE_SIZE,DEFAULT_DISCARD_POLICY);
}
public SimpleThreadPoolStop(int size, int queueSize, SimpleThreadPoolMyOne.DiscardPolicy discardPolicy) {
this.size = size;
this.queueSize = queueSize;
this.discardPolicy = discardPolicy;
init();
}
public int getSize() {
return size;
}
/**
* 判断是destory就不
* @return
*/
public boolean destory(){
return this.destory;
}
public int getQueueSize() {
return queueSize;
}
private void init() {
for (int i = 0; i < size; i++) {
createWorkTask();
}
}
private void createWorkTask() {//创建10个线程
WorkerTask task = new WorkerTask(GROUP, THREAD_PREFIX + (seq++));
task.start();
THREAD_QUEUE.add(task);
}
public void shutdown() throws InterruptedException {// 第一步：停止
while(!TASK_QUEUE.isEmpty()){//你不能马上shutdown我 必须等我执行完毕的
Thread.sleep(50);
}
int initVal = THREAD_QUEUE.size();
while(initVal>0){
for(WorkerTask task:THREAD_QUEUE){
if(task.getTaskState()==TaskState.BLOCKED){//只是释放wait的线程
task.interrupt();
task.close();
initVal--;
}else{
Thread.sleep(10);
}
}
}
this.destory = true;
System.out.println("The thread pool close");
}
private enum TaskState {
FREE, RUNNING, BLOCKED, DEAD
}
public static class DiscardException extends RuntimeException{
public DiscardException(String message){
super(message);
}
}
public interface DiscardPolicy{
void descard() throws SimpleThreadPoolMyOne.DiscardException;
}
public void submit(Runnable runnable) {// 第二步：关闭 不能提提交了
if(destory){
throw new IllegalStateException("the thread pool aleardy and not allow submit");
}
synchronized (TASK_QUEUE) {//别的方法有读的操作，这里有写的操作，所以你要加锁的
if(TASK_QUEUE.size()>queueSize){
discardPolicy.descard();
}
TASK_QUEUE.addLast(runnable);
TASK_QUEUE.notifyAll();
}
}
/**
* Thread in ThreadPool
*/
private static class WorkerTask extends Thread {//为什么定义为private呢就是为了不想让别人知道我是什么
private volatile TaskState taskState = TaskState.FREE;//每个任务都有自己的taskState
public WorkerTask(ThreadGroup group, String name) {//构造方法，调用了Thread的构造
super(group, name);
}
public TaskState getTaskState() {
return this.taskState;
}
public void close() {
this.taskState = TaskState.DEAD;
}
public void run() { //重写run方法保证执行完之后不能挂掉
OUTER:
while (this.taskState != TaskState.DEAD) { //当前的线程没有死掉 线程调用的方法都是while
Runnable runnable;
synchronized (TASK_QUEUE) { //去任务队列调取任务
while (TASK_QUEUE.isEmpty()) {
try {
this.taskState = TaskState.BLOCKED;
TASK_QUEUE.wait(); //没有任务就释放锁，这个线程在TASK_QUEUE上等待 wait会被打断 打断的话就break出来
} catch (InterruptedException e) {
break OUTER; //https://blog.csdn.net/zhaoheng2017/article/details/78385973 被打断了就接着去调取任务
}
}
runnable = TASK_QUEUE.removeFirst();//队列 先进先出 任务队列只被消费一次 比如数据库线程池，取出来我执行连接就可以了
}
if (runnable != null) { //任务不加锁去并行的
this.taskState = TaskState.RUNNING;
runnable.run();
this.taskState = TaskState.FREE;
}
}
}
}
}
我们是用shutdown去中断的，中断的话会做什么呢？
关于outer：https://blog.csdn.net/zhaoheng2017/article/details/78385973
-------------------------------------------------------------------------------37--------------------------------------------------------------------------------------
线程的信息，扩容线程池：
代码：
package chapter13;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class SimpleThreadMyMessage extends Thread {
private 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 = "MESSAGE_THREAD_POOL-";//采集线路名称标记
private final static ThreadGroup GROUP = new ThreadGroup("Pool_Group_CHANNEL");//采集组
private final static List<WorkerTask> THREAD_QUEUE = new ArrayList<>();//任务集合有几个线程
private final static LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();//工作队列去这里取做什么工作
private final SimpleThreadPoolMyOne.DiscardPolicy discardPolicy;
private volatile boolean destory = false;
private int min;
private int max;
private int active;
public int getMin() {
return min;
}
public void setMin(int min) {
this.min = min;
}
public int getMax() {
return max;
}
public void setMax(int max) {
this.max = max;
}
public int getActive() {
return active;
}
public void setActive(int active) {
this.active = active;
}
public final static SimpleThreadPoolMyOne.DiscardPolicy DEFAULT_DISCARD_POLICY = () -> {
throw new SimpleThreadPoolMyOne.DiscardException("Discard this task");
};
public SimpleThreadMyMessage() {
this(4,8,12,DEFAULT_TASK_QUEUE_SIZE, DEFAULT_DISCARD_POLICY);
}
public SimpleThreadMyMessage(int min,int active,int max,int queueSize, SimpleThreadPoolMyOne.DiscardPolicy discardPolicy) {// 第一步：状态得轮转
this.min = min;
this.active = active;
this.max = max;
this.queueSize = queueSize;
this.discardPolicy = discardPolicy;
init();
}
public int getSize() {
return size;
}
/**
* 判断是destory就不
*
* @return
*/
public boolean isDestoryestory() {
return this.destory;
}
public int getQueueSize() {
return queueSize;
}
private void init() {
for (int i = 0; i < this.min; i++) {
createWorkTask();
}
this.size = min;
this.start();//这个就是开启线程去判断线程池的属性的
}
private void createWorkTask() {//创建10个线程
WorkerTask task = new WorkerTask(GROUP, THREAD_PREFIX + (seq++));
task.start();
THREAD_QUEUE.add(task);
}
@Override
public void run() {
while (!destory) {
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_000);
if(TASK_QUEUE.size()>active&&size<active){
for(int i=size;i<active;i++){
createWorkTask();
}
System.out.println("The pool incremented to active.");
size = active;
}else if(TASK_QUEUE.size()>max&&size<max){
for(int i=size;i<max;i++){
createWorkTask();
}
System.out.println("The pool incremented to max.");
size = max;
}
synchronized (THREAD_QUEUE) {//为什么加锁 因为操作了it了
if (TASK_QUEUE.isEmpty() && size > active) {//TASK_QUEUE.isEmpty()没有任务了runnable才这样的
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.close();
task.interrupt();
it.remove();
releaseSize--;
}
size = active;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void shutdown() throws InterruptedException {
while (!TASK_QUEUE.isEmpty()) {//不能马上shutdown当前的流线路 必须等数据流执行完毕的
Thread.sleep(50);
}
int initVal = THREAD_QUEUE.size();
while (initVal > 0) {
for (WorkerTask task : THREAD_QUEUE) {
if (task.getTaskState() == TaskState.BLOCKED) {//只是释放wait的线路
task.interrupt();
task.close();
initVal--;
} else {
Thread.sleep(10);
}
}
}
this.destory = true;
System.out.println("The thread pool close");
}
private enum TaskState {
FREE, RUNNING, BLOCKED, DEAD
}
public static class DiscardException extends RuntimeException {
public DiscardException(String message) {
super(message);
}
}
public interface DiscardPolicy {
void descard() throws SimpleThreadPoolMyOne.DiscardException;
}
public void submit(Runnable runnable) {
if (destory) {
throw new IllegalStateException("the thread pool aleardy and not allow submit");
}
synchronized (TASK_QUEUE) {//别的方法有读的操作，这里有写的操作，所以你要加锁的
if (TASK_QUEUE.size() > queueSize) {
discardPolicy.descard();
}
TASK_QUEUE.addLast(runnable);
TASK_QUEUE.notifyAll();
}
}
/**
* Thread in ThreadPool
*/
private static class WorkerTask extends Thread {//为什么定义为private呢就是为了不想让别人知道我是什么
private volatile TaskState taskState = TaskState.FREE;//每个任务都有自己的taskState
public WorkerTask(ThreadGroup group, String name) {//构造方法，调用了Thread的构造
super(group, name);
}
public TaskState getTaskState() {
return this.taskState;
}
public void close() {
this.taskState = TaskState.DEAD;
}
public void run() { //重写run方法保证执行完之后不能挂掉
OUTER:
while (this.taskState != TaskState.DEAD) { //当前的线程没有死掉 线程调用的方法都是while
Runnable runnable;
synchronized (TASK_QUEUE) { //去任务队列调取任务
while (TASK_QUEUE.isEmpty()) {
try {
this.taskState = TaskState.BLOCKED;
TASK_QUEUE.wait(); //没有任务就释放锁，这个线程在TASK_QUEUE上等待 wait会被打断 打断的话就break出来
} catch (InterruptedException e) {
System.out.println("Closed.");//执行到这里肯定被打断了reduce
break OUTER; //https://blog.csdn.net/zhaoheng2017/article/details/78385973 被打断了就接着去调取任务
}
}
runnable = TASK_QUEUE.removeFirst();//队列 先进先出 任务队列只被消费一次 比如数据库线程池，取出来我执行连接就可以了
}
if (runnable != null) { //任务不加锁去并行的
this.taskState = TaskState.RUNNING;
runnable.run();
this.taskState = TaskState.FREE;
}
}
}
}
}
总结：第一步：继承Thread。
第二步：重写run方法。
第三步：重写iniit方法。
第四步：定义min active max等，再写run方法。
-------------------------------------------------------------------------------38--------------------------------------------------------------------------------------
略。
-------------------------------------------------------------------------------39--------------------------------------------------------------------------------------
扫一扫
1877
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
