線程池的實現(轉)

lsg615

線程池功能
應用程序可以有多個線程，這些線程在休眠狀態(tài)中需要耗費大量時間來等待事件發(fā)生。其他線程可能進入睡眠狀態(tài)，并且僅定期被喚醒以輪循更改或更新狀態(tài)信息，然后再次進入休眠狀態(tài)。為了簡化對這些線程的管理，.NET框架為每個進程提供了一個線程池，一個線程池有若干個等待操作狀態(tài)，當一個等待操作完成時，線程池中的輔助線程會執(zhí)行回調函數。線程池中的線程由系統(tǒng)管理，程序員不需要費力于線程管理，可以集中精力處理應用程序任務。
　　線程池是一種多線程處理形式，處理過程中將任務添加到隊列，然后在創(chuàng)建線程后自動啟動這些任務。線程池線程都是后臺線程.每個線程都使用默認的堆棧大小,以默認的優(yōu)先級運行,并處于多線程單元中.如果某個線程在托管代碼中空閑(如正在等待某個事件),則線程池將插入另一個輔助線程來使所有處理器保持繁忙.如果所有線程池線程都始終保持繁忙,但隊列中包含掛起的工作,則線程池將在一段時間后創(chuàng)建另一個輔助線程但線程的數目永遠不會超過最大值.超過最大值的線程可以排隊,但他們要等到其他線程完成后才啟動
什么情況下不要使用線程池
●如果需要使一個任務具有特定優(yōu)先級
●如果具有可能會長時間運行（并因此阻塞其他任務）的任務
●如果需要將線程放置到單線程單元中（線程池中的線程均處于多線程單元中）
●如果需要永久標識來標識和控制線程，比如想使用專用線程來終止該線程，將其掛起或按名稱發(fā)現它
System.ThreadingPool類實現了線程池，這是一個靜態(tài)類，它提供了管理線程的一系列方法
Threading.QueueUserItem方法在線程池中創(chuàng)建一個線程池線程來執(zhí)行指定方法（用委托WaitCallBack表示），并將該線程排入線程池的隊列等待執(zhí)行。
publc static Boolean QueueUserWorkItem(WaitCallback wc,Object state);
傳遞參數
調用QueueUserWorkItem時傳入的Object類型參數傳遞到任務過程，可以通過這種方式來向任務過程傳遞參數。如果任務過程需要多個參數，可以定義包含這些數據的類，并將其強制轉換為Object數據類型
線程池實例：

package threadpool;   

   

import ojadb.core.thread.OjadbThreadPool;   

import ojadb.core.thread.task.OjadbTask;   

import ojadb.exception.OjadbException;   

   

public class BasicTest {   

    public static void main(String[] ojadbs) throws OjadbException {   

        OjadbThreadPool pool = new OjadbThreadPool(5, 10);   

        OjadbTask thread = new OjadbTask("test thread");   

        pool.excute(thread);   

        System.exit(0);   

    }   

}   
線程池：

package ojadb.core.thread;   

   

import java.util.concurrent.BlockingQueue;   

import java.util.concurrent.LinkedBlockingQueue;   

import ojadb.core.thread.task.OjadbTask;   

import ojadb.core.thread.thread.OjadbThread;   

import ojadb.exception.OjadbException;   

   

public class OjadbThreadPool {   

    private int minimum;   

    private int maximum;   

    private LinkedBlockingQueue ojadbThreads;   

    private BlockingQueue ojadbTasks;   

   

    public OjadbThreadPool(int min, int max) throws OjadbException {   

        if (0  

            minimum = min;   

            maximum = max;   

            ojadbThreads = new LinkedBlockingQueue();   

            ojadbTasks = new LinkedBlockingQueue();   

            for (int i = 0; i  

                OjadbThread worker = new OjadbThread(this, "worker" + i);   

                worker.start();   

            }   

        } else {   

            throw new OjadbException("無法建立線程池: 最小值必須大于零,小于最大值");   

        }   

    }   

   

    public void addWorker(OjadbThread ojadbThreadWorker) {   

        ojadbThreads.offer(ojadbThreadWorker);   

    }   

   

    public void excute(OjadbTask thread) {   

        // 生產任務   

        ojadbTasks.offer(thread);   

   

        OjadbThread worker = ojadbThreads.remove();   

        if (worker != null) {   

            worker.work();   

        } else if (ojadbThreads.size()  

            OjadbThread newWorker = new OjadbThread(this, "worker" + ojadbThreads.size());   

            newWorker.start();   

        } else {   

   

        }   

        releaseThreads();   

    }   

   

    private void releaseThreads() {   

        while (ojadbThreads.size() > minimum) {   

            OjadbThread worker = ojadbThreads.remove();   

            System.out.println(worker + "is killed");   

            worker.kill();   

        }   

    }   

   

    public OjadbTask getTask() {   

        if (ojadbTasks.size() == 0)   

            return null;   

        // 消費任務   

        return ojadbTasks.remove();   

    }   

}   
內部線程：

package ojadb.core.thread.thread;   

   

import java.util.concurrent.locks.Condition;   

import java.util.concurrent.locks.ReentrantLock;   

   

import ojadb.core.thread.OjadbThreadPool;   

import ojadb.core.thread.task.OjadbTask;   

   

public class OjadbThread extends Thread {   

    private boolean isActived;   

    private ReentrantLock lock = new ReentrantLock();   

    private Condition condition = lock.newCondition();   

    private OjadbThreadPool pool;   

   

    public OjadbThread(OjadbThreadPool pool, String threadName) {   

        super(threadName);   

        this.pool = pool;   

        isActived = true;   

    }   

   

    @Override   

    public synchronized void start() {   

        super.start();   

    }   

   

    @Override   

    public void run() {   

        try {   

            lock.lock();   

   

            while (isActived) {   

                OjadbTask task = pool.getTask();   

                if (task != null) {   

                    String result = (String) task.excute();   

   

                    if (result.length() > 0) {   

                        pool.addWorker(this);   

                        // 懶工人策略 -- 沒人招呼工作，絕不睡醒   

                        condition.await();   

                    }   

                } else {   

                    pool.addWorker(this);   

                    condition.await();   

                }   

            }   

        } catch (InterruptedException e) {   

            e.printStackTrace();   

        } finally {   

            lock.unlock();   

        }   

    }   

   

    public void work() {   

        try {   

            lock.lock();   

            condition.signal();   

        } finally {   

            lock.unlock();   

        }   

    }   

   

    public void kill() {   

        isActived = false;   

        work();   

    }   

   

    @Override   

    public String toString() {   

        return getName();   

    }   

}   
用戶線程：

package ojadb.core.thread.task;   

   

public class OjadbTask {   

    private String threadName;   

   

    public OjadbTask(String threadName) {   

        this.threadName = threadName;   

    }   

   

    public Object excute() {   

        System.out.println("excuting " + threadName);   

        return "success";   

    }   

   

    public String getName() {   

        return threadName;   

    }   

   

    public String toString() {   

        return threadName;   

    }   

}  


本文來自ChinaUnix博客，如果查看原文請點：http://blog.chinaunix.net/u3/109669/showart_2142170.html