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 ){}
            }
        }
    }
}