The problem of thread pool

Question

I want to make a thread pool to handle UDP package request
so I set tow int variable :
norsize;
maxsize;
the norsize is normal amount threads when Server boot they will be creat;
the maxsize is when the quest is large and the norsize threads are not enough,The
Thead pool can increase to the amount
but how reduce the Thread pool amount when it reach the maxsize????

Answer 1

That was funy (the Duke Dollars part) :)
Ok. This time with some code.
We have a class that manages work. This work is made up of Runnable objects and the threads that run it. Let's go with sample code instead of english, just remenber that I wrote this code directly to the post text area and didn't event compile it, although it should work.
publi class WorkQueue {
    private LinkedList m_listRunnable;
    private int m_nMinThread;
    private int m_nMaxThread;
    private int m_nTimeOut;
    private int m_nNumThread;
    private int m_nNumThreadWaiting;
    public WorkQueue(int minThread, int maxThread, int timeOut) {
        m_listRunnable = new LinkedList();
        m_nMinThread = minThread;
        m_nMaxThread = maxThread;
        m_nTimeOut = timeOut;
        m_nNumThread = 0;
        m_nNumThreadWaiting = 0;
        init();
    private void init() {
        /* Start MinThread threads */
        for (i = 0; i < m_nMinThread; i++) {
             new WorkSlaveThread();
             m_nNumThread++;
    /* Inner class for the work thread */
    private class WorkSlaveThread extends Thread {
        public WorkSlaveThread() {
        public void run() {
            /* Work unless no work is returned, then it should stop */
            for (Runnable work = getNextWork(); work != null; work = getNextWork()) {
                try {
                    work.run();
                } catch (Throwable ex) {
                    /* Log the error */
                    ex.printStackTrace();
            threadStopping();
    private void threadStopping() {
        synchronized (this) {
            m_nNumThread--;
    private Runnable getNextWork() {
        Runnable work;
        long starttime = System.currentTimeMillis();
        long currenttime = starttime;
        long timeOut = m_nTimeOut * 1000; // Assume the time on in the constructor is in seconds
        synchronized (m_listRunnable) {
            /* Until there is work and the time out hasn't exceed */
            /* (time out ignored if the minimum umber of threads is reached) */
            while ((m_listRunnable.size() == 0) && ((timeOut > (currenttime - starttime)) || (m_nThreads == m_nMinThreads))) {
                try {
                    m_nNumThreadWaiting++;
                    m_listRunnable.wait(m_nTimeOut * 1000);
                } catch (Exception ex) {
                    /* Exception are launched if the VM is going down */
                    return null;
                } finally {
                    m_nNumThreadWaiting--;
                currenttime = System.currentTimeMillis();
            if (m_listRunnable.size () == 0) {
                /* Stop threads procedure */
                return null; // Null will stop the thread
            } else {
                work = (Runnable)m_listRunnable.remove(0);
                return work;
    public void addWork(Runnable work) {
        synchronized (m_listRunnable) {
            m_listRunnable.add(work);
            /* Start threads if necessary */
            if ((m_nNumThreadWaiting == 0) && (m_nNumThread < m_nMaxthread)) {
                new WorkSlaveThread();
                synchronized (this) {
                    m_nNumThread++;
            /* Signal a waiting thread */
            m_listRunnable.notify();
}Well, this about does it! I didn't compile this, nor this is the code I use internally (internally I have shutdown procedures to ensure all work is down and other things), but it should do all the things a mention previously (I don't think I forgot any thing).
Hope this helps,
Nuno