Java究竟怎么玩？

  我們大家都知道，在處理多線程服務并發時，由于創建線程需要占用很多的系統資源，所以為了避免這些不必要的損耗，通常我們采用線程池來解決這些問題。
  線程池的基本原理是，首先創建并保持一定數量的線程，當需要使用線程時，我們從池中取得線程，再將需要運行的任務交給線程進行處理，當任務完成后再將其釋放回池中。
 下面，我給出一個很簡單的實現模型，僅供參考。

 ThreadPool.java

package org.loon.framework.util.test;

import java.util.LinkedList;
import java.util.List;

/** *//**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:
 * </p>
 * <p>
 * Copyright: Copyright (c) 2007
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @version 0.1
 */
public class ThreadPool ...{

    private static ThreadPool instance = null;

    // 優先級低
    public static final int PRIORITY_LOW = 0;

    // 普通
    public static final int PRIORITY_NORMAL = 1;

    // 高
    public static final int PRIORITY_HIGH = 2;

    // 用以保存空閑連接
    private List[] _idxThreads;

    // 關閉
    private boolean _shutdown = false;

    // 線程數量
    private int _threadCount = 0;

    // debug信息是否輸出
    private boolean _debug = false;

    /** *//**
     * 返回ThreadPool實例
     * 
     * @return
     */
    public static ThreadPool getInstance() ...{
        if (instance == null) ...{
                    instance = new ThreadPool();
            }
        return instance;
    }

    // 初始化線程list
    private ThreadPool() ...{
        this._idxThreads = new List[] ...{ new LinkedList(), new LinkedList(),
                new LinkedList() };
        this._threadCount=0;
    }

    /** *//**
     * 同步方法，完成任務后將資源放回線程池中
     * @param repool
     */
    protected synchronized void repool(Pooled repool) ...{
        if (this._shutdown) ...{
            if (this._debug) ...{
                System.out.println("ThreadPool.repool():重設中……");
            }
            // 優先級別判定
            switch (repool.getPriority()) ...{
            case Thread.MIN_PRIORITY:
                this._idxThreads[PRIORITY_LOW].add(repool);
                break;
            case Thread.NORM_PRIORITY:
                this._idxThreads[PRIORITY_NORMAL].add(repool);
                break;
            case Thread.MAX_PRIORITY:
                this._idxThreads[PRIORITY_HIGH].add(repool);
                break;
            default:
                throw new IllegalStateException("沒有此種級別");
            }
            // 通知所有線程
            notifyAll();

        } else ...{
            if (this._debug) ...{
                System.out.println("ThreadPool.repool():注銷中……");
            }
            repool.shutDown();
        }
        if(this._debug)...{
            System.out.println("ThreadPool.repool():完成");
        }
    }
    public void setDebug(boolean debug)...{
        this._debug=debug;
    }
    public synchronized  void shutDown()...{
        this._shutdown=true;
        if(this._debug)...{
            System.out.println("ThreadPool.shutDown():關閉中……");
        }
        for(int index=0;index<=PRIORITY_NORMAL;index++)...{
            List threads=this._idxThreads[index];
            for(int threadIndex=0;threadIndex<threads.size();threadIndex++)...{
                Pooled idleThread=(Pooled)threads.get(threadIndex);
                idleThread.shutDown();
            }
        }
        notifyAll();
    }
    
    /** *//**
     * 以指定的優先級啟動線程
     * @param target
     * @param priority
     */
    public synchronized void start(Runnable target,int priority)...{
        Pooled thread=null;
        List idleList=this._idxThreads[priority];
        int idleSize=idleList.size();

        if(idleSize>0)...{
            int lastIndex=idleSize-1;
            thread=(Pooled)idleList.get(lastIndex);
            idleList.remove(idleList);
            thread.setTarget(target);
        }else...{
            this._threadCount++;
            thread=new Pooled(target,"Pooled->"+this._threadCount,this);
            switch(priority)...{
            
            case PRIORITY_LOW:
                thread.setPriority(Thread.MIN_PRIORITY);
                break;
            case PRIORITY_NORMAL:
                thread.setPriority(Thread.NORM_PRIORITY);
                break;
            case PRIORITY_HIGH:
                thread.setPriority(Thread.MAX_PRIORITY);
                break;
                default:
                    thread.setPriority(Thread.NORM_PRIORITY);
            }
            //啟動
            thread.start();
    
            }
        
        
    }

    /** *//**
     * 返回線程數量
     * 
     * @return
     */
    public int getThreadsCount() ...{
        return this._threadCount;
    }

}

Pooled.java:

package org.loon.framework.util.test;

/** *//**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:
 * </p>
 * <p>
 * Copyright: Copyright (c) 2007
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @version 0.1
 */
public class Pooled extends Thread ...{

    private ThreadPool _pool;

    private Runnable _target;

    private boolean _shutdown = false;

    private boolean _idle = false;

    public Pooled(Runnable target) ...{
        super(target);
    }

    public Pooled(Runnable target, String name) ...{
        super(target, name);
    }

    public Pooled(Runnable target, String name, ThreadPool pool) ...{
        super(name);
        this._pool = pool;
        this._target = target;
    }

    public Pooled(String name) ...{
        super(name);
    }

    public Pooled(ThreadGroup group, Runnable target) ...{
        super(group, target);
    }

    public Pooled(ThreadGroup group, Runnable target, String name) ...{
        super(group, target, name);
    }

    public Pooled(ThreadGroup group, String name) ...{
        super(group, name);
    }

    public Runnable getTarget() ...{
        return this._target;
    }

    public boolean isIdle() ...{
        return this._idle;
    }

    public void run() ...{
        while (!this._shutdown) ...{
            this._idle = false;
            if (this._target != null) ...{
                this._target.run();
            }
            this._idle = true;
            try ...{

                this._pool.repool(this);

                synchronized (this) ...{
                    wait();
                }

            } catch (InterruptedException ex) ...{
                System.err.println(ex.getMessage());
            }
            this._idle = false;
        }
    }

    public synchronized void setTarget(Runnable target) ...{
        this._target = target;
        notifyAll();
    }

    public synchronized void shutDown() ...{
        this._shutdown = true;
        notifyAll();
    }

}

測試用類：

package org.loon.framework.util.test;
/** *//**
 * <p>Title: LoonFramework</p>
 * <p>Description:線程池測試</p>
 * <p>Copyright: Copyright (c) 2007</p>
 * <p>Company: LoonFramework</p>
 * @author chenpeng  
 * @email：ceponline@yahoo.com.cn 
 * @version 0.1
 */
public class ThreadPoolTest ...{

    
    private static Runnable createRunnable(final int id) ...{
        return new Runnable() ...{
            public void run() ...{
                System.out.println("線程" + id + ",運行 ");
                try ...{
                    Thread.sleep(1000);
                }
                catch (InterruptedException ex) ...{ }
                System.out.println("線程" + id + ",結束");
            }
        };
    }
    
    public static void main(String[]args)...{
        ThreadPool pool=ThreadPool.getInstance();
        pool.setDebug(true);
         for (int i=1; i<=10; i++) ...{
             //根據數值，設定不同優先級
             if(i%2==0)...{
                     pool.start(createRunnable(i), ThreadPool.PRIORITY_HIGH);
             }else...{
                     pool.start(createRunnable(i), ThreadPool.PRIORITY_LOW);
             }
         }
        System.out.println("線程池測試中……");
        System.out.println("線程池線程總數:"+pool.getThreadsCount());
        pool.shutDown();
    }
}