java多线程 自定义线程池

首先自定义一个阻塞队列
队列中定义各种限制
一个简单的自定义阻塞队列：

public class MyMessageQueue<E> {
    private Object[] message;
    private int putIndex;
    private int takIndex;
    private volatile int size;

    public MyMessageQueue(int length) {
        message = new Object[length];
        putIndex = 0;//放元素的下标
        takIndex = 0;//取元素的下标
        size = 0; //实际元素个数
    }
    public synchronized void offer(E val) {
        try {
            while (size == message.length) {
                wait();
            }
            message[putIndex] = val;
            putIndex = (putIndex + 1) % message.length;
            //超出范围循环到队首
            size++;
            notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    public synchronized E poll() {
        E value = null;
        try {
            while (size == 0) {
                wait();
            }
            value = (E)message[takIndex];
            takIndex = (takIndex + 1) % message.length;
            size--;
            notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return value;
    }
}

自定义线程池MyThreadPoll

public class MyThreadPoll {
    //自定义固定大小的线程池
   private MyMessageQueue<Runnable> queue;
    //自定义阻塞队列

    public MyThreadPoll(int capacity, int size) {
        MyWorker[] workers = new MyWorker[capacity];
        queue = new MyMessageQueue<>(size);
        for (int i = 0; i < capacity; i++) {
            workers[i] = new MyWorker(queue);
            workers[i].start();
            //capacity 个线程的线程池；
            //线程池里的线程都启动（start();）,MyWorker里的run()运行；
        }
    }
    public void execute(Runnable task) {
        //利用execute 初始化队列
        queue.offer(task);
    }
}
class MyWorker extends Thread {
    private MyMessageQueue<Runnable> queue;

    public MyWorker(MyMessageQueue<Runnable> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        //这个run是重写的实际运行方法
        while (true) {
            //每个线程一直运行
            Runnable task = queue.poll();
            //运行条件是阻塞队列出队条件
            task.run();
            //区分：不同于start() ，start() 不会等待 start结束才进行下一步 ，而是直接下一步
            //这个run() 是普通的实例方法，等待run执行完才会下一步（继续while（true））判断出队条件 不满足则阻塞

            //有任务则运行，没任务则一直阻塞
        }
    }
}

这个可以实现简单的：
//可以实现简单的：

private static final ExecutorService EXE = 
	Executors.newSingleThreadExecutor(); //一个串形的线程
private static final ExecutorService EXE2 = 
	Executors.newFixedThreadPool(5);//5个同时进行
 

先这样吧，有bug再改