Azureus源码剖析（四）

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

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->publicabstractclassAEThread2
{
publicstaticfinalbooleanTRACE_TIMES=false;//是否跟踪线程运行时间

privatestaticfinalintMIN_RETAINED=2;//守护线程最小个数
privatestaticfinalintMAX_RETAINED=16;//守护线程最大个数

privatestaticfinalintTHREAD_TIMEOUT_CHECK_PERIOD=10*1000;//线程超时检查间隔期:10秒
privatestaticfinalintTHREAD_TIMEOUT=60*1000;//线程超时时限:60秒

privatestaticfinalLinkedListdaemon_threads=newLinkedList();//守护线程链表

privatestaticfinalclassJoinLock
{
volatilebooleanreleased=false;//初始状态锁未放开
}

privatestaticlonglast_timeout_check;//最近的超时检查时间

privatestaticlongtotal_starts;//启动的线程总数
privatestaticlongtotal_creates;//创建的线程总数


privatethreadWrapperwrapper;//线程包装器（实质的线程）

privateStringname;//线程名称
privatebooleandaemon;//是否守护线程
privateintpriority=Thread.NORM_PRIORITY;//线程优先级
privatevolatileJoinLocklock=newJoinLock();

publicAEThread2(String_name,boolean_daemon)
{
name=_name;
daemon=_daemon;
}
publicvoidstart()
{
JoinLockcurrentLock=lock;
JoinLocknewLock;

synchronized(currentLock)
{
//createnewlockincasethisisarestart,allold.join()swillbelockedontheoldthreadandthusreleasedbytheoldthread
if(currentLock.released)
newLock=lock=newJoinLock();
else
newLock=currentLock;
}

if(daemon)
{//是守护线程
synchronized(daemon_threads)
{
total_starts++;//启动的总线程数加1
if(daemon_threads.isEmpty())
{//若守护线程链表为空，则创建一个新线程
total_creates++;
wrapper=newthreadWrapper(name,true);
}
else
{//从守护线程链表中移除尾部节点
wrapper=(threadWrapper)daemon_threads.removeLast();
wrapper.setName(name);
}
}
}
else
{//不是守护线程

wrapper=newthreadWrapper(name,false);
}

if(priority!=wrapper.getPriority())
{//设置线程优先级
wrapper.setPriority(priority);
}

wrapper.currentLock=newLock;//传递锁

wrapper.start(this,name);//真正启动线程运行
}

publicvoidsetPriority(int_priority)
{
priority=_priority;
if(wrapper!=null)
{
wrapper.setPriority(priority);
}
}

publicvoidsetName(Strings)
{
name=s;
if(wrapper!=null)
{
wrapper.setName(name);
}
}

publicStringgetName()
{
return(name);
}

publicvoidinterrupt()
{
if(wrapper==null)
{
thrownewIllegalStateException("Interruptedbeforestarted!");

}
else
{
wrapper.interrupt();//中断线程
}
}

publicbooleanisCurrentThread()
{
return(wrapper==Thread.currentThread());
}

publicStringtoString()
{
if(wrapper==null)
{
return(name+"[daemon="+daemon+",priority="+priority+"]");

}
else
{
return(wrapper.toString());
}
}

publicabstractvoidrun();//实质的线程函数，在包装器类中调用

publicstaticbooleanisOurThread(Threadthread)
{
return(AEThread.isOurThread(thread));
}

publicstaticvoidsetOurThread()
{
AEThread.setOurThread();
}

publicstaticvoidsetOurThread(Threadthread)
{
AEThread.setOurThread(thread);
}

//实质的线程，从Thread类继承
protectedstaticclassthreadWrapperextendsThread
{
privateAESemaphoresem;
privateAEThread2target;//被包装的目标
privateJoinLockcurrentLock;//锁

privatelonglast_active_time;//最近活跃时间

protectedthreadWrapper(Stringname,booleandaemon)
{
super(name);
setDaemon(daemon);//设置是否守护线程
}

publicvoidrun()
{
while(true)
{
synchronized(currentLock)
{
try
{
if(TRACE_TIMES)
{
longstart_time=SystemTime.getHighPrecisionCounter();
longstart_cpu=Java15Utils.getThreadCPUTime();

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

}
finally
{
longtime_diff=(SystemTime.getHighPrecisionCounter()-start_time)/1000000;
longcpu_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(Throwablee)
{
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)
{
threadWrapperthread=(threadWrapper)daemon_threads.getFirst();//取链表头部
longthread_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;
}
}
}
}

protectedvoidstart(AEThread2_target,String_name)
{
target=_target;
setName(_name);
if(sem==null)
{
sem=newAESemaphore("AEThread2");
super.start();//启动线程
}
else
{
sem.release();
}
}

protectedvoidretire()
{
sem.release();
}
}

publicvoidjoin()
{//等待线程结束
JoinLockcurrentLock=lock;
//synclockwillbeblockedbythethread
synchronized(currentLock)
{
//waitincasethethreadisnotrunningyet
while(!currentLock.released)
{//若锁还未释放，则说明线程还在运行，则继续等待锁的释放，
try
{
currentLock.wait();
}
catch(InterruptedExceptione){}
}
}
}
}