请问：我想作一个简单的线程池，但是我不能确定一个事情，请对线程有研究朋友看看

Question

"保持已经完成任务线程实例，以后重新对内部数据赋值再次使用"这是不可能的，Java中，一个线程一旦执行完毕时不能重新开始的——就是说对于已经结束的线程对象再次调用start方法是不允许的。

Answer 1

实现起来比较复杂，有个思路：
你的线程首先应该是个有条件的无限循环，每次循环是一次工作如：
while(!stop){
//do something again and again
}
其次，线程执行完工作后，把自己放到池里。
再次，线程要用到wait()方法，完成工作后等待。
然后是有个标志来判断是否赋新值，如果赋了新值，并被激活，则根据该标志，决定是往下循环执行，还是继续等待。
最后，调度线程在池中取线程，向其赋值后，使用notifyAll激活所有线程。

Answer 2

本人目前项目中也有类似情况，我把这称为“资本家和工人”问题。打个比方，工厂有一些活要做，将工人分成三班，第一班做完布置的任务后就下班休息了，接着就是第二班、第三班跟进，很典型的“三班倒”，这是代表“工人阶级”立场的。还有一种方式就是所有工人不分早中晚，一班到底，当一个时段的任务完成后，下一任务还没来之前的这段时间内作等待状态，以等待继续被剥削._>:)，这是代表“资本家”利益的。在线程任务中，工人就代表着线程，在作业效率方面，到底是让一个线程完成任务后进入等待状态，以等待下一次任务的唤醒一继续任务高效呢？还是当次完成任务就释放线程，下次有任务再新开线程高效一些呢？本人在项目中没有能够得出结论，希望大家多多讨论。
"保持已经完成任务线程实例，以后重新对内部数据赋值再次使用" Polarislee(北极星) 朋友说得没错，一个Thread stop后是不能再次被start的，关键是让thread结束任务后不被stop而是进入wait状态，有新任务后再notify激活。利用bigcrazy(大疯狂) 朋友的思路完全可行。

Answer 3

/**
 * free software
 * from apusic
 * by www.cn-java.com 2001
 */import java.util.LinkedList;public class ThreadPool
{
    static final long IDLE_TIMEOUT = 60000L;    private String name;
    private int minsize;
    private int maxsize;
    private int nextWorkerId = 0;
    private LinkedList pool = new LinkedList();    public ThreadPool()
    {
        this("PooledThread");
    }    public ThreadPool(String name)
    {
        this(name, 0, 20);
    }    public ThreadPool(String name, int minsize, int maxsize)
    {
        this.name = name;
        this.minsize = minsize;
        this.maxsize = maxsize;
    }
    public synchronized void setSize(int min,int max)
    {
        minsize = min;
        maxsize = max;
    }
    public synchronized int getMinSize()
    {
        return minsize;
    }
    public synchronized int getMaxSize()
    {
        return maxsize;
    }
    public synchronized void run(Runnable runner)
    {
        Worker worker;        if(runner == null)
        {
            throw new NullPointerException();
        }        // get a worker from free list...
        if(!pool.isEmpty())
        {
            worker = (Worker)pool.removeFirst();
        }
        else
        {
            // ...no free worker available, create new one...
            worker = new Worker(name + "-" + ++nextWorkerId);
            worker.start();
        }        // ...and wake up worker to service incoming runner
        worker.wakeup(runner);
    }    // Notified when a worker has idled timeout
    // @return true if worker should die, false otherwise
    synchronized boolean notifyTimeout(Worker worker)
    {
        if(worker.runner != null)
        {
            return false;
        }
        if(pool.size() > minsize)
        {
            // Remove from free list
            pool.remove(worker);
            return true; // die
        }
        return false; // continue
    }    // Notified when a worker has finished his work and
    // free to service next runner
    // @return true if worker should die, false otherwise
    synchronized boolean notifyFree(Worker worker)
    {
        if(pool.size() < maxsize)
        {
            // Add to free list
            pool.addLast(worker);
            return false; // continue
        }
        return true; // die
    }    // The inner class that implement worker thread
    class Worker extends Thread
    {
        Runnable runner = null;        public Worker(String name)
        {
            super(name);
            this.setDaemon(true);
        }        synchronized void wakeup(Runnable runner)
        {
            this.runner = runner;
            notify();
        }        public void run()
        {
            for(; ; )
            {
                synchronized(this)
                {
                    if(runner == null)
                    {
                        try
                        {
                            wait(IDLE_TIMEOUT);
                        }
                        catch(InterruptedException e)
                        {}
                    }
                }                // idle timed out, die or put into free list
                if(runner == null)
                {
                    if(notifyTimeout(this))
                        return;
                    else
                        continue;
                }                try
                {
                    runner.run();
                }
                finally
                {
                    runner = null;
                    if(notifyFree(this))
                        return;
                }
            }
        }
    }
}