Azureus源码剖析（四）

AEThread只是一个简单的线程类，提供一个抽象方法runSupport 供我们重写，相必之下，AEThread2有几个改进的地方:1)加入了运行锁机制，运行线程和等待线程的结束这两个操作需要争抢运行锁，若锁未放开，则说明线程还在运行，必须等待锁的释放。2）设置了一个守护线程链表，若待创建的线程是守护线程，当链表为空时，新建一个守护线程加入表尾，否则从链表尾部取一个线程节点来使用，类似线程池。3)对于守护线程，若活跃时间超过时限，就会从守护线程链表中删除头部节点，即超时最长时间的节点。

 

public   abstract   class  AEThread2 
{
     public   static   final   boolean  TRACE_TIMES  =   false ; // 是否跟踪线程运行时间
    
     private   static   final   int  MIN_RETAINED     =   2 ; // 守护线程最小个数
     private   static   final   int  MAX_RETAINED     =   16 ; // 守护线程最大个数
    
     private   static   final   int  THREAD_TIMEOUT_CHECK_PERIOD     =   10 * 1000 ; // 线程超时检查间隔期:10秒
     private   static   final   int  THREAD_TIMEOUT                     =   60 * 1000 ; // 线程超时时限:60秒 
    
     private   static   final  LinkedList    daemon_threads  =   new  LinkedList(); // 守护线程链表
    
     private   static   final   class  JoinLock 
    {
         volatile   boolean  released  =   false ; // 初始状态锁未放开
    }
    
     private   static   long     last_timeout_check; // 最近的超时检查时间
    
     private   static   long     total_starts; // 启动的线程总数
     private   static   long     total_creates; // 创建的线程总数
    
    
     private  threadWrapper    wrapper; // 线程包装器（实质的线程）
    
     private  String name; // 线程名称
     private   boolean  daemon; // 是否守护线程
     private   int  priority  =  Thread.NORM_PRIORITY; // 线程优先级
     private   volatile  JoinLock lock  =   new  JoinLock();
    
     public  AEThread2(String    _name, boolean  _daemon )
    {
        name  =  _name;
        daemon  =  _daemon;
    }
     public   void  start()
    {
        JoinLock currentLock  =  lock;
        JoinLock newLock;
        
         synchronized  (currentLock)
        {
             //  create new lock in case this is a restart, all old .join()s will be locked on the old thread and thus released by the old thread
             if (currentLock.released)
                newLock  =  lock  =   new  JoinLock();
             else
                newLock  =  currentLock;
        }
        
         if  ( daemon )
        { // 是守护线程
             synchronized ( daemon_threads )
            {
                total_starts ++ ; // 启动的总线程数加1                
                 if  ( daemon_threads.isEmpty())
                { // 若守护线程链表为空，则创建一个新线程
                    total_creates ++ ;
                    wrapper  =   new  threadWrapper( name,  true  );            
                }
                 else
                { // 从守护线程链表中移除尾部节点
                    wrapper  =  (threadWrapper)daemon_threads.removeLast();
                    wrapper.setName( name );
                }
            }
        }
         else
        { // 不是守护线程
        
            wrapper  =   new  threadWrapper( name,  false  );
        }
        
         if  ( priority  !=  wrapper.getPriority() )
        { // 设置线程优先级
            wrapper.setPriority( priority );
        }
        
        wrapper.currentLock  =  newLock; // 传递锁
        
        wrapper.start(  this , name ); // 真正启动线程运行
    }
    
     public   void  setPriority( int  _priority )
    {
        priority     =  _priority;
         if  ( wrapper  !=   null  )
        {
            wrapper.setPriority( priority );
        }
    }
    
     public   void  setName(String    s )
    {
        name     =  s;
         if  ( wrapper  !=   null  )
        {
            wrapper.setName( name );
        }
    }
    
     public  String getName()
    {
         return ( name );
    }
    
     public   void  interrupt()
    {
         if  ( wrapper  ==   null  )
        {
             throw   new  IllegalStateException(  " Interrupted before started! "  );
            
        }
         else
        {
            wrapper.interrupt(); // 中断线程
        }
    }
    
     public   boolean  isCurrentThread()
    {
         return ( wrapper  ==  Thread.currentThread());
    }
    
     public  String toString()
    {
         if  ( wrapper  ==   null  )
        {
             return ( name  +   "  [daemon= "   +  daemon  +   " ,priority= "   +  priority  +   " ] "  );
            
        }
         else
        {
             return ( wrapper.toString());
        }
    }
    
     public   abstract   void  run(); // 实质的线程函数，在包装器类中调用
    
     public   static   boolean  isOurThread(Thread thread )
    {
         return ( AEThread.isOurThread( thread ));
    }
    
     public   static   void  setOurThread()
    {
        AEThread.setOurThread();
    }
    
     public   static   void  setOurThread(Thread    thread )
    {
        AEThread.setOurThread( thread );
    }
    
     // 实质的线程，从Thread类继承
     protected   static   class  threadWrapper  extends  Thread
    {
         private  AESemaphore sem;
         private  AEThread2    target;  // 被包装的目标
         private  JoinLock    currentLock; // 锁
        
         private   long         last_active_time; // 最近活跃时间
        
         protected  threadWrapper(String name, boolean  daemon )
        {
             super ( name );
            setDaemon( daemon ); // 设置是否守护线程
        }
        
         public   void  run()
        {
             while (  true  )
            {
                 synchronized ( currentLock )
                {
                     try
                    {
                         if  ( TRACE_TIMES )
                        {
                             long      start_time      =  SystemTime.getHighPrecisionCounter();
                             long     start_cpu      =  Java15Utils.getThreadCPUTime();

                             try
                            {
                                target.run(); // 实质的线程函数

                            }
                             finally
                            {
                                 long     time_diff      =  ( SystemTime.getHighPrecisionCounter()  -  start_time ) / 1000000 ;
                                 long     cpu_diff     =  ( Java15Utils.getThreadCPUTime()  -  start_cpu )  /   1000000 ;
                                
                                 if  ( cpu_diff  >   10   ||  time_diff  >   10  )
                                {
                                    System.out.println( TimeFormatter.milliStamp()  +   " : Thread:  "   +  target.getName()  +   " :  "   +  cpu_diff  +   " / "   +  time_diff );
                                }
                            }
                        }
                         else
                        {
                            target.run();
                        }
                                                
                    }
                     catch ( Throwable e )
                    {
                        DebugLight.printStackTrace(e);
                        
                    }
                     finally
                    { // 线程运行结束
                        target  =   null ;
                        currentLock.released  =   true ; // 释放锁
                        currentLock.notifyAll(); // 通知其他阻塞线程                        
                    }
                }
                                
                 if  ( isInterrupted()  ||   ! Thread.currentThread().isDaemon())
                { // 中断或不是守护线程
                     break ;
                    
                }
                 else
                { // 是守护线程                    
                     synchronized ( daemon_threads )
                    {                    
                        last_active_time     =  SystemTime.getCurrentTime();                        
                         if  (last_active_time  <  last_timeout_check  || last_active_time  -  last_timeout_check  >  THREAD_TIMEOUT_CHECK_PERIOD )
                        {
                            last_timeout_check     =  last_active_time;
                            
                             while ( daemon_threads.size()  >   0   &&  daemon_threads.size()  >  MIN_RETAINED )
                            {                                
                                threadWrapper thread  =  (threadWrapper)daemon_threads.getFirst(); // 取链表头部                                
                                 long     thread_time  =  thread.last_active_time;                                
                                 if  (last_active_time  <  thread_time  || last_active_time  -  thread_time  >  THREAD_TIMEOUT )
                                {                                    
                                    daemon_threads.removeFirst(); // 移除超时节点                                    
                                    thread.retire(); // 被移除节点信号量释放
                                    
                                }
                                 else
                                {                                
                                     break ;
                                }
                            }
                        }                
                         if  ( daemon_threads.size()  >=  MAX_RETAINED )
                        {                        
                             return ;
                        }
                        daemon_threads.addLast(  this  ); // 将此守护节点加入守护线程链表尾部，这样头部应该是最先超时的节点
                        setName(  " AEThead2:parked[ "   +  daemon_threads.size()  +   " ] "  );                        
                         //  System.out.println( "AEThread2: queue=" + daemon_threads.size() + ",creates=" + total_creates + ",starts=" + total_starts );
                    }                    
                    sem.reserve(); // 新加入节点信号量增加                    
                     if  ( target  ==   null  )
                    {                        
                         break ;
                    }
                }
            }
        }
        
         protected   void  start(AEThread2    _target,String        _name )
        {
            target     =  _target;            
            setName( _name );            
             if  ( sem  ==   null  )
            {                
                 sem  =   new  AESemaphore(  " AEThread2 "  );                 
                  super .start(); // 启动线程             
            }
             else
            {                
                sem.release();
            }
        }
        
         protected   void  retire()
        {            
            sem.release();
        }
    }
    
     public   void  join()
    { // 等待线程结束
        JoinLock currentLock  =  lock;
         //  sync lock will be blocked by the thread        
         synchronized ( currentLock )
        {            
             //  wait in case the thread is not running yet            
             while  ( ! currentLock.released )
            { // 若锁还未释放，则说明线程还在运行，则继续等待锁的释放，                
                 try
                {
                    currentLock.wait();                    
                }
                 catch ( InterruptedException e ){}
            }
        }
    }
}