JAVA线程池的实现 和 优先级设置

import java.util.LinkedList;
import java.util.List;
 
/**
 *
 * Title: LoonFramework
 *
 *
 * Description:
 *
 *
 * Copyright: Copyright (c) 2007
 *
 *
 * Company: LoonFramework
 *
 *
 * @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;
    }
 
}
 
 
 
 
/**
 *
 * Title: LoonFramework
 *
 *
 * Description:
 *
 *
 * Copyright: Copyright (c) 2007
 *
 *
 * Company: LoonFramework
 *
 *
 * @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;
/** *//**
* Title: LoonFramework
* Description:线程池测试
* Copyright: Copyright (c) 2007
* Company: LoonFramework
* @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();
}
}