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]