初次学习多线程——自己写的一个线程池

package com.lovo.threadpool;

public class ThreadOfPool extends Thread{
    private Runnable task = null;
    private ThreadPool threadPool;
    private boolean stop = false;//线程状态
    public ThreadOfPool() {
    }
    public ThreadOfPool(ThreadPool threadPool) {
        this.threadPool = threadPool;
    }
    /**
     * 给线程分配指定的任务
     * @param task
     */
    public synchronized void setTask(Runnable task) {
        this.task = task;
        notify();
    }
    /**
     * 线程执行
     */
    private synchronized void executeTask() {
        while (!stop) {
            while (!stop && task == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    stop = true;
                }
            }
            if (task != null) {
                task.run();
                task = null;
                threadPool.free(this);
            }
        }
    }
    @Override
    public void run() {
        executeTask();
    }
    public Runnable getTask() {
        return task;
    }
    public void setStop(boolean stop) {
        this.stop = stop;
    }
    
}

package com.lovo.threadpool;

import java.util.ArrayList;
import java.util.List;

public class ThreadPool {
    private List<Thread> freeThreads = new ArrayList<Thread>();//空闲线程（可用）
    private List<Thread> usingThreads = new ArrayList<Thread>();//正在被使用的线程（不可用）
    private int POOL_SIZE = 5;
    public ThreadPool(){
        this(POOL_SIZE);
    }
    public ThreadPool(int num){
        POOL_SIZE = num;
        for (int i = 0; i < POOL_SIZE; i++) {
            ThreadOfPool tempThread = new ThreadOfPool(this);
            tempThread.start();
            freeThreads.add(tempThread);
        }
    }
    /**
     * 分配一个线程
     * @param t
     */
    public synchronized void execute(Runnable t) {
        while (freeThreads.isEmpty()) {
//            System.out.println("线程池繁忙，请等待！");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ThreadOfPool tempthread= (ThreadOfPool) freeThreads.remove(freeThreads.size() - 1);
        usingThreads.add(tempthread);
        tempthread.setTask(t);
    }
    /**
     * 分配的线程用完后的回收处理
     * @param threadOfPool
     */
    public synchronized void free(ThreadOfPool threadOfPool) {
        usingThreads.remove(threadOfPool);
        freeThreads.add(threadOfPool);
        notify();
    }
    /**
     * 关闭线程池
     */
    public void close() {
        while (freeThreads.size() < POOL_SIZE) {}
        for (Thread thread : freeThreads) {
            thread.interrupt();
        }
    }
}