以前做的東西，實現一個簡單的多線程機制，開始之前，現說說原理性的東西吧，下面是我在ibm開發者上搜到的內容

線程池的技術背景

在面向對象編程中，創建和銷毀對象是很費時間的，因為創建一個對象要獲取內存資源或者其它更多資源。在Java中更是如此，虛擬機將試圖跟蹤每一個對象， 以便能夠在對象銷毀后進行垃圾回收。所以提高服務程序效率的一個手段就是盡可能減少創建和銷毀對象的次數，特別是一些很耗資源的對象創建和銷毀。如何利用 已有對象來服務就是一個需要解決的關鍵問題，其實這就是一些"池化資源"技術產生的原因。

多線程技術主要解決處理器單元內多個線程執行的問題，它可以顯著減少處理器單元的閑置時間，增加處理器單元的吞吐能力。但如果對多線程應用不當，會增加對單個任務的處理時間。可以舉一個簡單的例子：

假設在一臺服務器完成一項任務的時間為T

◆  T1 創建線程的時間

◆ T2 在線程中執行任務的時間，包括線程間同步所需時間

◆ T3 線程銷毀的時間

顯然T ＝ T1＋T2＋T3。注意這是一個極度簡化的假設。

可以看出T1,T3是多線程本身的帶來的開銷，我們渴望減少T1,T3所用的時間，從而減少T的時間。但一些線程的使用者并沒有注意到 這一點，所以在程序中頻繁的創建或銷毀線程，這導致T1和T3在T中占有相當比例。顯然這是突出了線程的弱點（T1，T3），而不是優點（并發性）。

線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高服務器程序性能的。它把T1，T3分別安排在服務器程序的啟動和結束的時間段或者一些空閑的時間段，這樣在服務器程序處理客戶請求時，不會有T1，T3的開銷了。

線程池不僅調整T1,T3產生的時間段，而且它還顯著減少了創建線程的數目。在看一個例子：

假設一個服務器一天要處理50000個請求，并且每個請求需要一個單獨的線程完成。我們比較利用線程池技術和不利于線程池技術的服務器 處理這些請求時所產生的線程總數。在線程池中，線程數一般是固定的，所以產生線程總數不會超過線程池中線程的數目或者上限（以下簡稱線程池尺寸），而如果 服務器不利用線程池來處理這些請求則線程總數為50000。一般線程池尺寸是遠小于50000。所以利用線程池的服務器程序不會為了創建50000而在處 理請求時浪費時間，從而提高效率。

這些都是假設，不能充分說明問題，下面我將討論線程池的簡單實現并對該程序進行對比測試，以說明線程技術優點及應用領域。

一般一個簡單線程池至少包含下列組成部分

◆ 線程池管理器（ThreadPoolManager）：用于創建并管理線程池

◆ 工作線程（WorkThread）： 線程池中線程

◆ 任務接口（Task）：每個任務必須實現的接口，以供工作線程調度任務的執行。

◆ 任務隊列：用于存放沒有處理的任務。提供一種緩沖機制。

線程池管理器至少有下列功能：創建線程池，銷毀線程池，添加新任務。下面就是小弟的實現，還是歡迎拍磚哈：

public class ThreadPoolManager {  
    private static ThreadPoolManager instance = null;  
    private List<Upload> taskQueue = Collections.synchronizedList(new LinkedList<Upload>());//任務隊列  
    private WorkThread[] workQueue ;    //工作線程（真正執行任務的線程）  
    private static int worker_num = 5;    //工作線程數量（默認工作線程數量是5）  
    private static int worker_count = 0;  
      
    private ThreadPoolManager(){  
        this(5);  
    }  
    private ThreadPoolManager(int num){  
        worker_num = num;  
        workQueue = new WorkThread[worker_num];  
        for(int i=0;i<worker_num;i++){  
            workQueue[i] = new WorkThread(i);  
        }  
    }  
      
    public static synchronized ThreadPoolManager getInstance(){  
        if(instance==null)  
            instance = new ThreadPoolManager();  
        return instance;  
    }  
      
    public void addTask(Upload task){  
        //對任務隊列的操作要上鎖  
        synchronized (taskQueue) {  
            if(task!=null){  
                taskQueue.add(task);  
                taskQueue.notifyAll();  
                System.out.println("task id "+task.getInfo() + " submit!");  
            }  
                  
        }  
    }  
      
    public void BatchAddTask(Upload[] tasks){  
        //對任務隊列的修改操作要上鎖  
        synchronized (taskQueue) {  
            for(Upload e:tasks){  
                if(e!=null){  
                    taskQueue.add(e);  
                    taskQueue.notifyAll();  
                    System.out.println("task id "+e.getInfo() + " submit!");  
                }  
            }          
        }  
    }  
      
    public void destory(){  
        System.out.println("pool begins to destory ...");  
        for(int i = 0;i<worker_num;i++){  
            workQueue[i].stopThread();  
            workQueue[i] = null;  
        }  
        //對任務隊列的操作要上鎖  
        synchronized (taskQueue) {  
            taskQueue.clear();  
        }  
          
        System.out.println("pool ends to destory ...");  
    }  
      
    private class WorkThread extends Thread{  
        private int taksId ;  
        private boolean isRuning = true;  
        private boolean isWaiting = false;  
          
          
           
        public WorkThread(int taskId){  
            this.taksId= taskId;  
            this.start();  
        }  
          
        public boolean isWaiting(){  
            return isWaiting;  
        }  
        // 如果任務進行中時，不能立刻終止線程，需要等待任務完成之后檢測到isRuning為false的時候，退出run()方法  
        public void stopThread(){  
            isRuning = false;  
        }  
          
        @Override 
        public void run() {  
            while(isRuning){  
                Upload temp = null;  
                //對任務隊列的操作要上鎖  
                synchronized (taskQueue) {  
                    //任務隊列為空，等待新的任務加入  
                    while(isRuning&&taskQueue.isEmpty()){  
                        try {  
                            taskQueue.wait(20);  
                        } catch (InterruptedException e) {  
                            System.out.println("InterruptedException occre...");  
                            e.printStackTrace();  
                        }  
                    }  
                    if(isRuning)  
                        temp = taskQueue.remove(0);  
                }  
                //當等待新任務加入時候，終止線程(調用stopThread函數)造成 temp ＝ null  
                if(temp!=null){  
                    System.out.println("task info: "+temp.getInfo()+ " is begining");  
                    isWaiting = false;  
                    temp.uploadPic();  
                    isWaiting = true;  
                    System.out.println("task info: "+temp.getInfo()+ " is finished");  
                }      
            }  
        }  
    }  
} 

然后定義任務接口（Task）：這里我定義的是上傳圖片的功能接口(這里用抽象類或者接口隨你自己)。

public abstract class Upload {  
    protected String info;  
    abstract boolean uploadPic();  
    public String getInfo(){  
        return info;  
    }  
} 

然后定義具體任務類：我這里簡單，讓它睡眠2s。當然你也可以定義很多實現Upload的任務類。

public class TaskUpload extends Upload {  
      
    public TaskUpload(String info){  
        this.info = info;  
    }  
    public String getInfo(){  
        return info;  
    }  
    @Override 
    public boolean uploadPic()  {  
        // TODO Auto-generated method stub  
        System.out.println(info+"sleep begin ....");  
        try {  
            Thread.sleep(2000);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        System.out.println(info+"sleep end ....");  
        return false;  
    }  
} 

***，測試這個簡單的線程池：

public class ThreadPoolManagerTest {  
 
 
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        Upload[] tasks = createBatchTask(7);  
        ThreadPoolManager pool = ThreadPoolManager.getInstance();  
        pool.BatchAddTask(tasks);  
        pool.destory();  
    }  
    private static Upload[] createBatchTask(int n){  
        Upload[] tasks = new TaskUpload[n];  
        for(int i = 0;i<n ;i++ ){  
            tasks[i] = new TaskUpload("task id is "+ i);  
        }  
        return tasks;  
    }  
} 

線程池技術適用范圍及應注意的問題

線程池的應用范圍：

1、需要大量的線程來完成任務，且完成任務的時間比較短。 WEB服務器完成網頁請求這樣的任務，使用線程池技術是非常合適的。因為單個任務小，而任務數量巨大，你可以想象一個熱門網站的點擊次數。 但對于長時間的任務，比如一個Telnet連接請求，線程池的優點就不明顯了。因為Telnet會話時間比線程的創建時間大多了。

2、對性能要求苛刻的應用，比如要求服務器迅速相應客戶請求。

3、接受突發性的大量請求，但不至于使服務器因此產生大量線程的應用。突發性大量客戶請求，在沒有線程池情況下，將產生大量線程，雖然理論上大部分操作系統線程數目***值不是問題，短時間內產生大量線程可能使內存到達極限，并出現"OutOfMemory"的錯誤。

原文鏈接：http://www.cnblogs.com/slider/archive/2012/01/16/2323895.html

【編輯推薦】

1. Java回調函數的理解
2. Java路線圖：甲骨文的兩年計劃
3. Java 8將支持無符號整型
4. 深入研究Java虛擬機的類加載機制
5. Swing多線程編碼過程中的誤區