了解下JAVA的Java多线程：“JUC锁”04之公允锁(二) - 仓酷云

/*
*ORACLEPROPRIETARY/CONFIDENTIAL.Useissubjecttolicenseterms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/*
*
*
*
*
*
*WrittenbyDougLeawithassistancefrommembersofJCPJSR-166
*ExpertGroupandreleasedtothepublicdomain,asexplainedat
*http://creativecommons.org/publicdomain/zero/1.0/
*/
packagejava.util.concurrent.locks;
importjava.util.*;
importjava.util.concurrent.*;
importjava.util.concurrent.atomic.*;
/**
*Areentrantmutualexclusion{@linkLock}withthesamebasic
*behaviorandsemanticsastheimplicitmonitorlockaccessedusing
*{@codesynchronized}methodsandstatements,butwithextended
*capabilities.
*
*A{@codeReentrantLock}isownedbythethreadlast
*successfullylocking,butnotyetunlockingit.Athreadinvoking
*{@codelock}willreturn,successfullyacquiringthelock,when
*thelockisnotownedbyanotherthread.Themethodwillreturn
*immediatelyifthecurrentthreadalreadyownsthelock.Thiscan
*becheckedusingmethods{@link#isHeldByCurrentThread},and{@link
*#getHoldCount}.
*
*Theconstructorforthisclassacceptsanoptional
*fairnessparameter.Whenset{@codetrue},under
*contention,locksfavorgrantingaccesstothelongest-waiting
*thread.Otherwisethislockdoesnotguaranteeanyparticular
*accessorder.Programsusingfairlocksaccessedbymanythreads
*maydisplayloweroverallthroughput(i.e.,areslower;oftenmuch
*slower)thanthoseusingthedefaultsetting,buthavesmaller
*variancesintimestoobtainlocksandguaranteelackof
*starvation.Notehowever,thatfairnessoflocksdoesnotguarantee
*fairnessofthreadscheduling.Thus,oneofmanythreadsusinga
*fairlockmayobtainitmultipletimesinsuccessionwhileother
*activethreadsarenotprogressingandnotcurrentlyholdingthe
*lock.
*Alsonotethattheuntimed{@link#tryLock()tryLock}methoddoesnot
*honorthefairnesssetting.Itwillsucceedifthelock
*isavailableevenifotherthreadsarewaiting.
*
*Itisrecommendedpracticetoalwaysimmediately
*followacallto{@codelock}witha{@codetry}block,most
*typicallyinabefore/afterconstructionsuchas:
*
*<pre>
*classX{
*privatefinalReentrantLocklock=newReentrantLock();
*//...
*
*publicvoidm(){
*lock.lock();//blockuntilconditionholds
*try{
*//...methodbody
*}finally{
*lock.unlock()
*}
*}
*}
*</pre>
*
*Inadditiontoimplementingthe{@linkLock}interface,this
*classdefinesmethods{@codeisLocked}and
*{@codegetLockQueueLength},aswellassomeassociated
*{@codeprotected}accessmethodsthatmaybeusefulfor
*instrumentationandmonitoring.
*
*Serializationofthisclassbehavesinthesamewayasbuilt-in
*locks:adeserializedlockisintheunlockedstate,regardlessof
*itsstatewhenserialized.
*
*Thislocksupportsamaximumof2147483647recursivelocksby
*thesamethread.Attemptstoexceedthislimitresultin
*{@linkError}throwsfromlockingmethods.
*
*@since1.5
*@authorDougLea
*/
publicclassReentrantLockimplementsLock,java.io.Serializable{
privatestaticfinallongserialVersionUID=7373984872572414699L;
/**Synchronizerprovidingallimplementationmechanics*/
privatefinalSyncsync;
/**
*Baseofsynchronizationcontrolforthislock.Subclassed
*intofairandnonfairversionsbelow.UsesAQSstateto
*representthenumberofholdsonthelock.
*/
abstractstaticclassSyncextendsAbstractQueuedSynchronizer{
privatestaticfinallongserialVersionUID=-5179523762034025860L;
/**
*Performs{@linkLock#lock}.Themainreasonforsubclassing
*istoallowfastpathfornonfairversion.
*/
abstractvoidlock();
/**
*Performsnon-fairtryLock.tryAcquireis
*implementedinsubclasses,butbothneednonfair
*tryfortrylockmethod.
*/
finalbooleannonfairTryAcquire(intacquires){
finalThreadcurrent=Thread.currentThread();
intc=getState();
if(c==0){
if(compareAndSetState(0,acquires)){
setExclusiveOwnerThread(current);
returntrue;
}
}
elseif(current==getExclusiveOwnerThread()){
intnextc=c+acquires;
if(nextc<0)//overflow
thrownewError("Maximumlockcountexceeded");
setState(nextc);
returntrue;
}
returnfalse;
}
protectedfinalbooleantryRelease(intreleases){
intc=getState()-releases;
if(Thread.currentThread()!=getExclusiveOwnerThread())
thrownewIllegalMonitorStateException();
booleanfree=false;
if(c==0){
free=true;
setExclusiveOwnerThread(null);
}
setState(c);
returnfree;
}
protectedfinalbooleanisHeldExclusively(){
//Whilewemustingeneralreadstatebeforeowner,
//wedontneedtodosotocheckifcurrentthreadisowner
returngetExclusiveOwnerThread()==Thread.currentThread();
}
finalConditionObjectnewCondition(){
returnnewConditionObject();
}
//Methodsrelayedfromouterclass
finalThreadgetOwner(){
returngetState()==0?null:getExclusiveOwnerThread();
}
finalintgetHoldCount(){
returnisHeldExclusively()?getState():0;
}
finalbooleanisLocked(){
returngetState()!=0;
}
/**
*Reconstitutesthislockinstancefromastream.
*@paramsthestream
*/
privatevoidreadObject(java.io.ObjectInputStreams)
throwsjava.io.IOException,ClassNotFoundException{
s.defaultReadObject();
setState(0);//resettounlockedstate
}
}
/**
*Syncobjectfornon-fairlocks
*/
staticfinalclassNonfairSyncextendsSync{
privatestaticfinallongserialVersionUID=7316153563782823691L;
/**
*Performslock.Tryimmediatebarge,backinguptonormal
*acquireonfailure.
*/
finalvoidlock(){
if(compareAndSetState(0,1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protectedfinalbooleantryAcquire(intacquires){
returnnonfairTryAcquire(acquires);
}
}
/**
*Syncobjectforfairlocks
*/
staticfinalclassFairSyncextendsSync{
privatestaticfinallongserialVersionUID=-3000897897090466540L;
finalvoidlock(){
acquire(1);
}
/**
*FairversionoftryAcquire.Dontgrantaccessunless
*recursivecallornowaitersorisfirst.
*/
protectedfinalbooleantryAcquire(intacquires){
finalThreadcurrent=Thread.currentThread();
intc=getState();
if(c==0){
if(!hasQueuedPredecessors()&&
compareAndSetState(0,acquires)){
setExclusiveOwnerThread(current);
returntrue;
}
}
elseif(current==getExclusiveOwnerThread()){
intnextc=c+acquires;
if(nextc<0)
thrownewError("Maximumlockcountexceeded");
setState(nextc);
returntrue;
}
returnfalse;
}
}
/**
*Createsaninstanceof{@codeReentrantLock}.
*Thisisequivalenttousing{@codeReentrantLock(false)}.
*/
publicReentrantLock(){
sync=newNonfairSync();
}
/**
*Createsaninstanceof{@codeReentrantLock}withthe
*givenfairnesspolicy.
*
*@paramfair{@codetrue}ifthislockshoulduseafairorderingpolicy
*/
publicReentrantLock(booleanfair){
sync=fair?newFairSync():newNonfairSync();
}
/**
*Acquiresthelock.
*
*Acquiresthelockifitisnotheldbyanotherthreadandreturns
*immediately,settingthelockholdcounttoone.
*
*Ifthecurrentthreadalreadyholdsthelockthenthehold
*countisincrementedbyoneandthemethodreturnsimmediately.
*
*Ifthelockisheldbyanotherthreadthenthe
*currentthreadbecomesdisabledforthreadscheduling
*purposesandliesdormantuntilthelockhasbeenacquired,
*atwhichtimethelockholdcountissettoone.
*/
publicvoidlock(){
sync.lock();
}
/**
*Acquiresthelockunlessthecurrentthreadis
*{@linkplainThread#interruptinterrupted}.
*
*Acquiresthelockifitisnotheldbyanotherthreadandreturns
*immediately,settingthelockholdcounttoone.
*
*Ifthecurrentthreadalreadyholdsthislockthentheholdcount
*isincrementedbyoneandthemethodreturnsimmediately.
*
*Ifthelockisheldbyanotherthreadthenthe
*currentthreadbecomesdisabledforthreadscheduling
*purposesandliesdormantuntiloneoftwothingshappens:
*
*<ul>
*
*<li>Thelockisacquiredbythecurrentthread;or
*
*<li>Someotherthread{@linkplainThread#interruptinterrupts}the
*currentthread.
*
*</ul>
*
*Ifthelockisacquiredbythecurrentthreadthenthelockhold
*countissettoone.
*
*Ifthecurrentthread:
*
*<ul>
*
*<li>hasitsinterruptedstatussetonentrytothismethod;or
*
*<li>is{@linkplainThread#interruptinterrupted}whileacquiring
*thelock,
*
*</ul>
*
*then{@linkInterruptedException}isthrownandthecurrentthreads
*interruptedstatusiscleared.
*
*Inthisimplementation,asthismethodisanexplicit
*interruptionpoint,preferenceisgiventorespondingtothe
*interruptovernormalorreentrantacquisitionofthelock.
*
*@throwsInterruptedExceptionifthecurrentthreadisinterrupted
*/
publicvoidlockInterruptibly()throwsInterruptedException{
sync.acquireInterruptibly(1);
}
/**
*Acquiresthelockonlyifitisnotheldbyanotherthreadatthetime
*ofinvocation.
*
*Acquiresthelockifitisnotheldbyanotherthreadand
*returnsimmediatelywiththevalue{@codetrue},settingthe
*lockholdcounttoone.Evenwhenthislockhasbeensettousea
*fairorderingpolicy,acallto{@codetryLock()}will
*immediatelyacquirethelockifitisavailable,whetherornot
*otherthreadsarecurrentlywaitingforthelock.
*This"barging"behaviorcanbeusefulincertain
*circumstances,eventhoughitbreaksfairness.Ifyouwanttohonor
*thefairnesssettingforthislock,thenuse
*{@link#tryLock(long,TimeUnit)tryLock(0,TimeUnit.SECONDS)}
*whichisalmostequivalent(italsodetectsinterruption).
*
*Ifthecurrentthreadalreadyholdsthislockthenthehold
*countisincrementedbyoneandthemethodreturns{@codetrue}.
*
*Ifthelockisheldbyanotherthreadthenthismethodwillreturn
*immediatelywiththevalue{@codefalse}.
*
*@return{@codetrue}ifthelockwasfreeandwasacquiredbythe
*currentthread,orthelockwasalreadyheldbythecurrent
*thread;and{@codefalse}otherwise
*/
publicbooleantryLock(){
returnsync.nonfairTryAcquire(1);
}
/**
*Acquiresthelockifitisnotheldbyanotherthreadwithinthegiven
*waitingtimeandthecurrentthreadhasnotbeen
*{@linkplainThread#interruptinterrupted}.
*
*Acquiresthelockifitisnotheldbyanotherthreadandreturns
*immediatelywiththevalue{@codetrue},settingthelockholdcount
*toone.Ifthislockhasbeensettouseafairorderingpolicythen
*anavailablelockwillnotbeacquiredifanyotherthreads
*arewaitingforthelock.Thisisincontrasttothe{@link#tryLock()}
*method.Ifyouwantatimed{@codetryLock}thatdoespermitbargingon
*afairlockthencombinethetimedandun-timedformstogether:
*
*<pre>if(lock.tryLock()||lock.tryLock(timeout,unit)){...}
*</pre>
*
*Ifthecurrentthread
*alreadyholdsthislockthentheholdcountisincrementedbyoneand
*themethodreturns{@codetrue}.
*
*Ifthelockisheldbyanotherthreadthenthe
*currentthreadbecomesdisabledforthreadscheduling
*purposesandliesdormantuntiloneofthreethingshappens:
*
*<ul>
*
*<li>Thelockisacquiredbythecurrentthread;or
*
*<li>Someotherthread{@linkplainThread#interruptinterrupts}
*thecurrentthread;or
*
*<li>Thespecifiedwaitingtimeelapses
*
*</ul>
*
*Ifthelockisacquiredthenthevalue{@codetrue}isreturnedand
*thelockholdcountissettoone.
*
*Ifthecurrentthread:
*
*<ul>
*
*<li>hasitsinterruptedstatussetonentrytothismethod;or
*
*<li>is{@linkplainThread#interruptinterrupted}while
*acquiringthelock,
*
*</ul>
*then{@linkInterruptedException}isthrownandthecurrentthreads
*interruptedstatusiscleared.
*
*Ifthespecifiedwaitingtimeelapsesthenthevalue{@codefalse}
*isreturned.Ifthetimeislessthanorequaltozero,themethod
*willnotwaitatall.
*
*Inthisimplementation,asthismethodisanexplicit
*interruptionpoint,preferenceisgiventorespondingtothe
*interruptovernormalorreentrantacquisitionofthelock,and
*overreportingtheelapseofthewaitingtime.
*
*@paramtimeoutthetimetowaitforthelock
*@paramunitthetimeunitofthetimeoutargument
*@return{@codetrue}ifthelockwasfreeandwasacquiredbythe
*currentthread,orthelockwasalreadyheldbythecurrent
*thread;and{@codefalse}ifthewaitingtimeelapsedbefore
*thelockcouldbeacquired
*@throwsInterruptedExceptionifthecurrentthreadisinterrupted
*@throwsNullPointerExceptionifthetimeunitisnull
*
*/
publicbooleantryLock(longtimeout,TimeUnitunit)
throwsInterruptedException{
returnsync.tryAcquireNanos(1,unit.toNanos(timeout));
}
/**
*Attemptstoreleasethislock.
*
*Ifthecurrentthreadistheholderofthislockthenthehold
*countisdecremented.Iftheholdcountisnowzerothenthelock
*isreleased.Ifthecurrentthreadisnottheholderofthis
*lockthen{@linkIllegalMonitorStateException}isthrown.
*
*@throwsIllegalMonitorStateExceptionifthecurrentthreaddoesnot
*holdthislock
*/
publicvoidunlock(){
sync.release(1);
}
/**
*Returnsa{@linkCondition}instanceforusewiththis
*{@linkLock}instance.
*
*Thereturned{@linkCondition}instancesupportsthesame
*usagesasdothe{@linkObject}monitormethods({@link
*Object#wait()wait},{@linkObject#notifynotify},and{@link
*Object#notifyAllnotifyAll})whenusedwiththebuilt-in
*monitorlock.
*
*<ul>
*
*<li>Ifthislockisnotheldwhenanyofthe{@linkCondition}
*{@linkplainCondition#await()waiting}or{@linkplain
*Condition#signalsignalling}methodsarecalled,thenan{@link
*IllegalMonitorStateException}isthrown.
*
*<li>Whenthecondition{@linkplainCondition#await()waiting}
*methodsarecalledthelockisreleasedand,beforethey
*return,thelockisreacquiredandthelockholdcountrestored
*towhatitwaswhenthemethodwascalled.
*
*<li>Ifathreadis{@linkplainThread#interruptinterrupted}
*whilewaitingthenthewaitwillterminate,an{@link
*InterruptedException}willbethrown,andthethreads
*interruptedstatuswillbecleared.
*
*<li>WaitingthreadsaresignalledinFIFOorder.
*
*<li>Theorderingoflockreacquisitionforthreadsreturning
*fromwaitingmethodsisthesameasforthreadsinitially
*acquiringthelock,whichisinthedefaultcasenotspecified,
*butforfairlocksfavorsthosethreadsthathavebeen
*waitingthelongest.
*
*</ul>
*
*@returntheConditionobject
*/
publicConditionnewCondition(){
returnsync.newCondition();
}
/**
*Queriesthenumberofholdsonthislockbythecurrentthread.
*
*Athreadhasaholdonalockforeachlockactionthatisnot
*matchedbyanunlockaction.
*
*Theholdcountinformationistypicallyonlyusedfortestingand
*debuggingpurposes.Forexample,ifacertainsectionofcodeshould
*notbeenteredwiththelockalreadyheldthenwecanassertthat
*fact:
*
*<pre>
*classX{
*ReentrantLocklock=newReentrantLock();
*//...
*publicvoidm(){
*assertlock.getHoldCount()==0;
*lock.lock();
*try{
*//...methodbody
*}finally{
*lock.unlock();
*}
*}
*}
*</pre>
*
*@returnthenumberofholdsonthislockbythecurrentthread,
*orzeroifthislockisnotheldbythecurrentthread
*/
publicintgetHoldCount(){
returnsync.getHoldCount();
}
/**
*Queriesifthislockisheldbythecurrentthread.
*
*Analogoustothe{@linkThread#holdsLock}methodforbuilt-in
*monitorlocks,thismethodistypicallyusedfordebuggingand
*testing.Forexample,amethodthatshouldonlybecalledwhile
*alockisheldcanassertthatthisisthecase:
*
*<pre>
*classX{
*ReentrantLocklock=newReentrantLock();
*//...
*
*publicvoidm(){
*assertlock.isHeldByCurrentThread();
*//...methodbody
*}
*}
*</pre>
*
*Itcanalsobeusedtoensurethatareentrantlockisused
*inanon-reentrantmanner,forexample:
*
*<pre>
*classX{
*ReentrantLocklock=newReentrantLock();
*//...
*
*publicvoidm(){
*assert!lock.isHeldByCurrentThread();
*lock.lock();
*try{
*//...methodbody
*}finally{
*lock.unlock();
*}
*}
*}
*</pre>
*
*@return{@codetrue}ifcurrentthreadholdsthislockand
*{@codefalse}otherwise
*/
publicbooleanisHeldByCurrentThread(){
returnsync.isHeldExclusively();
}
/**
*Queriesifthislockisheldbyanythread.Thismethodis
*designedforuseinmonitoringofthesystemstate,
*notforsynchronizationcontrol.
*
*@return{@codetrue}ifanythreadholdsthislockand
*{@codefalse}otherwise
*/
publicbooleanisLocked(){
returnsync.isLocked();
}
/**
*Returns{@codetrue}ifthislockhasfairnesssettrue.
*
*@return{@codetrue}ifthislockhasfairnesssettrue
*/
publicfinalbooleanisFair(){
returnsyncinstanceofFairSync;
}
/**
*Returnsthethreadthatcurrentlyownsthislock,or
*{@codenull}ifnotowned.Whenthismethodiscalledbya
*threadthatisnottheowner,thereturnvaluereflectsa
*best-effortapproximationofcurrentlockstatus.Forexample,
*theownermaybemomentarily{@codenull}evenifthereare
*threadstryingtoacquirethelockbuthavenotyetdoneso.
*Thismethodisdesignedtofacilitateconstructionof
*subclassesthatprovidemoreextensivelockmonitoring
*facilities.
*
*@returntheowner,or{@codenull}ifnotowned
*/
protectedThreadgetOwner(){
returnsync.getOwner();
}
/**
*Querieswhetheranythreadsarewaitingtoacquirethislock.Notethat
*becausecancellationsmayoccuratanytime,a{@codetrue}
*returndoesnotguaranteethatanyotherthreadwillever
*acquirethislock.Thismethodisdesignedprimarilyforusein
*monitoringofthesystemstate.
*
*@return{@codetrue}iftheremaybeotherthreadswaitingto
*acquirethelock
*/
publicfinalbooleanhasQueuedThreads(){
returnsync.hasQueuedThreads();
}
/**
*Querieswhetherthegiventhreadiswaitingtoacquirethis
*lock.Notethatbecausecancellationsmayoccuratanytime,a
*{@codetrue}returndoesnotguaranteethatthisthread
*willeveracquirethislock.Thismethodisdesignedprimarilyforuse
*inmonitoringofthesystemstate.
*
*@paramthreadthethread
*@return{@codetrue}ifthegiventhreadisqueuedwaitingforthislock
*@throwsNullPointerExceptionifthethreadisnull
*/
publicfinalbooleanhasQueuedThread(Threadthread){
returnsync.isQueued(thread);
}
/**
*Returnsanestimateofthenumberofthreadswaitingto
*acquirethislock.Thevalueisonlyanestimatebecausethenumberof
*threadsmaychangedynamicallywhilethismethodtraverses
*internaldatastructures.Thismethodisdesignedforusein
*monitoringofthesystemstate,notforsynchronization
*control.
*
*@returntheestimatednumberofthreadswaitingforthislock
*/
publicfinalintgetQueueLength(){
returnsync.getQueueLength();
}
/**
*Returnsacollectioncontainingthreadsthatmaybewaitingto
*acquirethislock.Becausetheactualsetofthreadsmaychange
*dynamicallywhileconstructingthisresult,thereturned
*collectionisonlyabest-effortestimate.Theelementsofthe
*returnedcollectionareinnoparticularorder.Thismethodis
*designedtofacilitateconstructionofsubclassesthatprovide
*moreextensivemonitoringfacilities.
*
*@returnthecollectionofthreads
*/
protectedCollection<Thread>getQueuedThreads(){
returnsync.getQueuedThreads();
}
/**
*Querieswhetheranythreadsarewaitingonthegivencondition
*associatedwiththislock.Notethatbecausetimeoutsand
*interruptsmayoccuratanytime,a{@codetrue}returndoes
*notguaranteethatafuture{@codesignal}willawakenany
*threads.Thismethodisdesignedprimarilyforusein
*monitoringofthesystemstate.
*
*@paramconditionthecondition
*@return{@codetrue}ifthereareanywaitingthreads
*@throwsIllegalMonitorStateExceptionifthislockisnotheld
*@throwsIllegalArgumentExceptionifthegivenconditionis
*notassociatedwiththislock
*@throwsNullPointerExceptioniftheconditionisnull
*/
publicbooleanhasWaiters(Conditioncondition){
if(condition==null)
thrownewNullPointerException();
if(!(conditioninstanceofAbstractQueuedSynchronizer.ConditionObject))
thrownewIllegalArgumentException("notowner");
returnsync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
/**
*Returnsanestimateofthenumberofthreadswaitingonthe
*givenconditionassociatedwiththislock.Notethatbecause
*timeoutsandinterruptsmayoccuratanytime,theestimate
*servesonlyasanupperboundontheactualnumberofwaiters.
*Thismethodisdesignedforuseinmonitoringofthesystem
*state,notforsynchronizationcontrol.
*
*@paramconditionthecondition
*@returntheestimatednumberofwaitingthreads
*@throwsIllegalMonitorStateExceptionifthislockisnotheld
*@throwsIllegalArgumentExceptionifthegivenconditionis
*notassociatedwiththislock
*@throwsNullPointerExceptioniftheconditionisnull
*/
publicintgetWaitQueueLength(Conditioncondition){
if(condition==null)
thrownewNullPointerException();
if(!(conditioninstanceofAbstractQueuedSynchronizer.ConditionObject))
thrownewIllegalArgumentException("notowner");
returnsync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)
condition);
}
/**
*Returnsacollectioncontainingthosethreadsthatmaybe
*waitingonthegivenconditionassociatedwiththislock.
*Becausetheactualsetofthreadsmaychangedynamicallywhile
*constructingthisresult,thereturnedcollectionisonlya
*best-effortestimate.Theelementsofthereturnedcollection
*areinnoparticularorder.Thismethodisdesignedto
*facilitateconstructionofsubclassesthatprovidemore
*extensiveconditionmonitoringfacilities.
*
*@paramconditionthecondition
*@returnthecollectionofthreads
*@throwsIllegalMonitorStateExceptionifthislockisnotheld
*@throwsIllegalArgumentExceptionifthegivenconditionis
*notassociatedwiththislock
*@throwsNullPointerExceptioniftheconditionisnull
*/
protectedCollection<Thread>getWaitingThreads(Conditioncondition){
if(condition==null)
thrownewNullPointerException();
if(!(conditioninstanceofAbstractQueuedSynchronizer.ConditionObject))
thrownewIllegalArgumentException("notowner");
returnsync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)
condition);
}
/**
*Returnsastringidentifyingthislock,aswellasitslockstate.
*Thestate,inbrackets,includeseithertheString{@code"Unlocked"}
*ortheString{@code"Lockedby"}followedbythe
*{@linkplainThread#getNamename}oftheowningthread.
*
*@returnastringidentifyingthislock,aswellasitslockstate
*/
publicStringtoString(){
Threado=sync.getOwner();
returnsuper.toString()+((o==null)?
"[Unlocked]":
"[Lockedbythread"+o.getName()+"]
");
}
}

复制代码