java并发编程实战wwj----------------------第一阶段--------------35-36-37-38-39

最新推荐文章于 2020-02-25 19:29:52 发布

nzch

最新推荐文章于 2020-02-25 19:29:52 发布

阅读量424

点赞数

分类专栏：并发 wwj并发

本文链接：https://blog.csdn.net/qq_28764557/article/details/103575987

版权

并发同时被 2 个专栏收录

99 篇文章 0 订阅

订阅专栏

wwj并发

14 篇文章 0 订阅

订阅专栏

线程一般是并发包里面的东西，我们重新写一个线程是没有必要的，我们手写线程是是为了掌握他的原理等。

线程是非常重的：

线程池为什么要有它：

线程创建要开辟虚拟机栈，释放线程要垃圾回收的。

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--------------------------------------------------------------------------------------