【线程】线程池的思考

本篇属于自我理解，如有地方出错，希望能提出来，谢谢。

线程池是什么?

一个管理器，将任务分配给空闲的线程，不够使用的话，可以创建新的线程，任务完成后，可以将多余的线程消亡掉。

为什么要创建线程池？

能够快速的响应进行处理任务，省去了创建和销毁线程的步骤，降低资源的消耗，重复使用线程，可以进行统一的分配和管理，使用效率更高。

线程池的状态？

RUNNING：接受新任务，处理任务。

SHUTDOWN:不接受新任务，处理任务。

STOP:不接受新任务，不处理任务，并且中断处理中的任务。

TIDYING:所有任务中断后的状态，任务数量为0。

TERMINATED:线程池彻底终止。

怎么维护线程池的状态？

用volatile修饰int，存储状态。volatile的理解为，修改其值后，会通知使用到这个值的线程，重新获取内存值。

线程的状态？

NEW：新建一个线程对象，但是还没有开始处理任务。

RUNNABLE：READY和RUNNING的统称，理解为调用start()方法后的状态。READY(线程进入可运行的线程池中，等待被调度使用)，RUNNING（获取到CPU的使用权，开始处理任务）。

BLOCKED：线程阻塞。

WAITING：等待其他线程的通知（继续处理任务或者中断任务），不处理任务。

TIMEAD_WAITING：也不处理任务，超时后自行返回，不需要其他地方的通知。

TERAMINATED：线程执行完毕。

package com.example.myapplication;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.locks.ReentrantLock;

public class MyThreadPoolExecutor {
    //线程池的核心线程数
    private volatile int poolSize = 2;
    //当前使用的线程池的线程数
    private volatile int coreSize = 0;
    //最大线程池的线程数
    private volatile int maxCoreSize ;

    //是否正在运行
    private volatile boolean RUNNING = true;
    //并发锁
    private final ReentrantLock lock = new ReentrantLock();
    //不重复的工作集
    private final HashSet<Worker> workers = new HashSet();
    //任务阻塞队列
    private static ArrayBlockingQueue<Runnable> queue = null;
    //线程工厂
    private final ArrayList<Thread> threads = new ArrayList<>();
    //是否停止工作
    private volatile boolean shutDown = false;

    public MyThreadPoolExecutor() {
        maxCoreSize = poolSize * 2;
        queue = new ArrayBlockingQueue<Runnable>(maxCoreSize);
    }

    public void execute(Runnable command) {
        if (command == null) {
            throw new NullPointerException();
        }

        if (coreSize < poolSize) {
            addThread(command);
        } else if (coreSize < maxCoreSize) {
            try {
                queue.put(command);
                System.out.println("添加到队列，当前队列长度："+queue.size());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            System.out.println("线程不够用了！！！！");
            throw new RuntimeException();
        }
    }

    private void addThread(Runnable task) {
        lock.lock();
        try {
            coreSize++;
            Worker worker = new Worker(task);
            workers.add(worker);
            Thread thread = new Thread(worker);
            threads.add(thread);
            thread.start();
            System.out.println("创建线程："+coreSize);
        } finally {
            lock.unlock();
        }
    }

    public void shutDown() {
        RUNNING = false;
        if (!workers.isEmpty()) {
            for (Worker worker : workers) {
                worker.interruptIfIdle();
            }
        }
        shutDown = true;
        Thread.currentThread().interrupt();
    }

    private final class Worker implements Runnable {
        public Worker(Runnable task) {
            queue.offer(task);
        }

        public Runnable getTask() throws InterruptedException {
            return queue.take();
        }

        @Override
        public void run() {
            while (true && RUNNING) {
                if (shutDown) {
                    Thread.interrupted();
                }
                Runnable task = null;
                try {
                    task = getTask();
                    task.run();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public void interruptIfIdle() {
            for (Thread thread : threads) {
                System.out.println(thread.getName() + "interrupt");
                thread.interrupt();
            }
        }
    }
}