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：[email]ceponline@yahoo.com.cn[/email]
* @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：[email]ceponline@yahoo.com.cn[/email]
* @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：[email]ceponline@yahoo.com.cn[/email]
* @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();
        }
}

本文出自 「 Java究竟怎麼玩」 博客，請務必保留此出處 [url]http://cping1982.blog.51cto.com/601635/130180[/url]