`

A simple thread pool implementation

阅读更多
java 代码
  1. import java.util.Vector;   
  2.   
  3. /**  
  4.  * Thread pool  
  5.  */  
  6. public class ThreadPool implements Runnable {   
  7.   
  8.     // Default ThreadPool minimum size   
  9.     public final static int DEFAULT_MIN_SIZE = 0;   
  10.   
  11.     // Default ThreadPool maximum size   
  12.     public final static int DEFAULT_MAX_SIZE = Integer.MAX_VALUE;   
  13.   
  14.     public final static long DEFAULT_RELEASE_DELAY = 10 * 1000;   
  15.   
  16.     // customized thread pool minimum size   
  17.     protected int minSize;   
  18.   
  19.     // customized thread pool maximum size   
  20.     protected int maxSize;   
  21.   
  22.     protected long releaseDelay;   
  23.   
  24.     // current threads size in threadpool   
  25.     protected int currentSize;   
  26.        
  27.     protected int availableThreads;   
  28.   
  29.     // task list   
  30.     protected Vector taskList;   
  31.   
  32.     /**  
  33.      * customized ThradPool  
  34.      *   
  35.      * @param minSize  
  36.      *            minimum thread pool size  
  37.      * @param maxSize  
  38.      *            maximum thread pool size  
  39.      * @param releaseDelay  
  40.      *            threads release delay  
  41.      */  
  42.     public ThreadPool(int minSize, int maxSize, long releaseDelay) {   
  43.         this.minSize = minSize;   
  44.         this.maxSize = maxSize;   
  45.         this.releaseDelay = releaseDelay;   
  46.         taskList = new Vector(100);   
  47.         availableThreads = 0;   
  48.     }   
  49.   
  50.     /**  
  51.      * Default ThreadPool  
  52.      */  
  53.     public ThreadPool() {   
  54.         this(DEFAULT_MIN_SIZE, DEFAULT_MIN_SIZE, DEFAULT_RELEASE_DELAY);   
  55.     }   
  56.   
  57.     /**  
  58.      * set minimum thread pool size  
  59.      *   
  60.      * @param minSize  
  61.      *            minimum thread pool size  
  62.      */  
  63.     public synchronized void setMinSize(int minSize) {   
  64.         this.minSize = minSize;   
  65.     }   
  66.   
  67.     /**  
  68.      * get minimum thread pool size  
  69.      */  
  70.     public synchronized int getMinSize() {   
  71.         return minSize;   
  72.     }   
  73.   
  74.     /**  
  75.      * set maximum thread pool size  
  76.      *   
  77.      * @param maxSize  
  78.      *            maximum thread pool size  
  79.      */  
  80.     public synchronized void setMaxSize(int maxSize) {   
  81.         this.maxSize = maxSize;   
  82.     }   
  83.   
  84.     /**  
  85.      * get maximum thread pool size  
  86.      */  
  87.     public synchronized int getMaxSize() {   
  88.         return maxSize;   
  89.     }   
  90.   
  91.     /**  
  92.      * set thread release delay  
  93.      *   
  94.      * @param releaseDelay  
  95.      *            thread release delay time  
  96.      */  
  97.     public synchronized void setReleaseDelay(long releaseDelay) {   
  98.         this.releaseDelay = releaseDelay;   
  99.     }   
  100.   
  101.     /**  
  102.      * get thread release delay  
  103.      */  
  104.     public synchronized long getReleaseDelay() {   
  105.         return releaseDelay;   
  106.     }   
  107.   
  108.     /**  
  109.      * add a task to task list of ThreadPool  
  110.      *   
  111.      * @param runnable  
  112.      *            new task  
  113.      */  
  114.     public synchronized void addTask(Runnable runnable) {   
  115.   
  116.         taskList.addElement(runnable);   
  117.         if (availableThreads > 0) {   
  118.             this.notify();   
  119.         } else {   
  120.             if (currentSize < maxSize) {   
  121.                 Thread t = new Thread(this);   
  122.                 currentSize++;   
  123.                 t.start();   
  124.             }   
  125.         }   
  126.     }   
  127.   
  128.     public void run() {   
  129.         Runnable task;   
  130.         while (true) {   
  131.             synchronized (this) {   
  132.                 if (currentSize > maxSize) {   
  133.                     currentSize--;   
  134.                     break;   
  135.                 }   
  136.                 task = getNextTask();   
  137.                 if (task == null) {   
  138.                     try {   
  139.                         availableThreads++;   
  140.                         wait(releaseDelay);   
  141.                         availableThreads--;   
  142.                     } catch (InterruptedException ie) {   
  143.                         // do something you wanna   
  144.                     }   
  145.                     task = getNextTask();   
  146.                     if (task == null) {   
  147.                         if (currentSize < minSize)   
  148.                             continue;   
  149.                         currentSize--;   
  150.                         break;   
  151.                     }   
  152.                 }   
  153.             }   
  154.             try {   
  155.                 task.run();   
  156.             } catch (Exception e) {   
  157.                 System.err.println("Uncaught exception");   
  158.                 e.printStackTrace(System.err);   
  159.             }   
  160.         }   
  161.     }   
  162.   
  163.     /**  
  164.      * get the next task from task list.  
  165.      *   
  166.      */  
  167.     protected synchronized Runnable getNextTask() {   
  168.         Runnable task = null;   
  169.         if (taskList.size() > 0) {   
  170.             task = (Runnable) (taskList.elementAt(0));   
  171.             taskList.removeElementAt(0);   
  172.         }   
  173.         return task;   
  174.     }   
  175.   
  176.     /**  
  177.      * return thread pool message  
  178.      */  
  179.     public String toString() {   
  180.         StringBuffer sb = new StringBuffer();   
  181.         sb.append("DEFAULT_MIN_SIZE : " + DEFAULT_MIN_SIZE + "\n");   
  182.         sb.append("DEFAULT_MAX_SIZE : " + DEFAULT_MAX_SIZE + "\n");   
  183.         sb.append("DEFAULT_RELEASE_DELAY : " + DEFAULT_RELEASE_DELAY + "\n");   
  184.         sb.append("the information about your's construct ThreadPool below : \n");   
  185.         sb.append("minSize \t maxSize \t releaseDelay \n");   
  186.         sb.append(minSize + "\t" + maxSize + "\t" + releaseDelay);   
  187.   
  188.         return sb.toString();   
  189.     }   
  190.   
  191. }   
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics