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

 

insulator  发表于2008年1月20日 15:44:16   IP: 删除

我对上面的程序修改测试后,发现在测试程序后面再加一段获取线程的程序.发现能从线程中取线程,但是发现取的都是同一个线程,不是很明白.
修改部分如下:
ThreadPoolTest.java中main()的pool.shutDown();下面增加了以下程序
try {
Thread.sleep(10000);
}
catch (InterruptedException ex) { }
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("II线程池测试中……");
System.out.println("II线程池线程总数:"+pool.getThreadsCount());
pool.shutDown();

在ThreadPool.java中新增了一段输出的程序:
public synchronized void start(Runnable target, int priority) {
.....................................
if (idleSize > 0) {
System.out.println("get thread :"+idleSize);
int lastIndex = idleSize - 1;
thread = (Pooled) idleList.get(lastIndex);
idleList.remove(idleList);
thread.setTarget(target);
}
...................................
}

发现输出一直都是get thread :5

cping1982  发表于2008年1月23日 10:13:08   IP: 删除

这 个例子程序是一个不完全的线程池，只实现了一些简单的功能，您所见返回的idleSize，其实并不是所有的线程数量，而是PRIORITY设定后缓存在 _idxThreads中的（_idxThreads[PRIORITY_LOW].add(repool);），由于在此例中shutdown()后并 没有清空_idxThreads，所以再次设定优先级会造成_idxThreads中已有数据。您所见thread:5为设定优先级低者的List数量， 您可以重新实例化ThreadPool或者变更shutdown()内部代码解决。