Add TimerQueue.stop()

js-labs · js-labs · commit 27a25e8c47a0 · 2022-02-09T21:59:14.000+03:00
diff --git a/src/main/java/org/jsl/collider/TimerQueue.java b/src/main/java/org/jsl/collider/TimerQueue.java
@@ -40,7 +40,7 @@
 
 public class TimerQueue extends ThreadPool.Runnable
 {
-    private static final Logger s_logger = Logger.getLogger( TimerQueue.class.getName() );
+    private static final Logger s_logger = Logger.getLogger(TimerQueue.class.getName());
 
     public interface Task
     {
@@ -56,6 +56,7 @@ public interface Task
     private final Condition m_cond;
     private final TreeMap<Long, TimerInfo> m_sortedTimers;
     private final Map<Task, TimerInfo> m_timers;
+    private boolean m_stop;
 
     private class TimerInfo extends ThreadPool.Runnable
     {
@@ -66,23 +67,24 @@ private class TimerInfo extends ThreadPool.Runnable
         public long threadID;
         public Condition cond;
 
-        public TimerInfo( Task task )
+        public TimerInfo(Task task, long fireTime)
         {
             this.task = task;
+            this.fireTime = fireTime;
         }
 
         public void runInThreadPool()
         {
-            assert( threadID == -1 );
-            assert( prev == null );
-            assert( next == null );
+            assert(threadID == -1);
+            assert(prev == null);
+            assert(next == null);
             threadID = Thread.currentThread().getId();
             final long interval = task.run();
-            restateTimer( this, interval );
+            restateTimer(this, interval);
         }
     }
 
-    private void restateTimer( TimerInfo timerInfo, long interval )
+    private void restateTimer(TimerInfo timerInfo, long interval)
     {
         boolean snatchThread = false;
 
@@ -92,7 +94,7 @@ private void restateTimer( TimerInfo timerInfo, long interval )
             if (timerInfo.cond != null)
             {
                 if (s_logger.isLoggable(Level.FINER))
-                    s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) + ": pending cancel" );
+                    s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) + ": pending cancel");
 
                 timerInfo.threadID = -2;
                 timerInfo.cond.signalAll();
@@ -106,22 +108,22 @@ else if (interval > 0)
                 {
                     if (s_logger.isLoggable(Level.FINER))
                     {
-                        s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) +
-                                ": interval=" + interval + ", snatch thread" );
+                        s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) +
+                                ": interval=" + interval + ", snatch thread");
                     }
-                    m_sortedTimers.put( fireTime, timerInfo );
+                    m_sortedTimers.put(fireTime, timerInfo);
                     snatchThread = true;
                 }
                 else
                 {
-                    final TimerInfo next = m_sortedTimers.get( fireTime );
-                    m_sortedTimers.put( fireTime, timerInfo );
+                    final TimerInfo next = m_sortedTimers.get(fireTime);
+                    m_sortedTimers.put(fireTime, timerInfo);
                     if (next == null)
                     {
                         if (s_logger.isLoggable(Level.FINER))
                         {
-                            s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) +
-                                    ": interval=" + interval + ", wakeup thread" );
+                            s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) +
+                                    ": interval=" + interval + ", wakeup thread");
                         }
                         if (m_sortedTimers.firstKey() == fireTime)
                             m_cond.signal();
@@ -130,8 +132,8 @@ else if (interval > 0)
                     {
                         if (s_logger.isLoggable(Level.FINER))
                         {
-                            s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) +
-                                    ": interval=" + interval );
+                            s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) +
+                                    ": interval=" + interval);
                         }
                         timerInfo.next = next;
                         next.prev = timerInfo;
@@ -141,8 +143,8 @@ else if (interval > 0)
             else
             {
                 if (s_logger.isLoggable(Level.FINER))
-                    s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) + ": done" );
-                m_timers.remove( timerInfo.task );
+                    s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) + ": done");
+                m_timers.remove(timerInfo.task);
             }
         }
         finally
@@ -162,21 +164,21 @@ public void runInThreadPool()
         m_lock.lock();
         try
         {
-            while (!m_sortedTimers.isEmpty())
+            while (!m_sortedTimers.isEmpty() && !m_stop)
             {
                 final Map.Entry<Long, TimerInfo> firstEntry = m_sortedTimers.firstEntry();
-                assert( firstEntry != null );
+                assert(firstEntry != null);
 
                 final long currentTime = System.currentTimeMillis();
                 if (firstEntry.getKey() <= currentTime)
                 {
                     if (s_logger.isLoggable(Level.FINER))
-                        s_logger.log( Level.FINER, "fireTime=" + firstEntry.getKey() + ": execute" );
+                        s_logger.log(Level.FINER, "fireTime=" + firstEntry.getKey() + ": execute");
 
                     TimerInfo timerInfo = firstEntry.getValue();
                     do
                     {
-                        assert( timerInfo.threadID == 0 );
+                        assert(timerInfo.threadID == 0);
                         final TimerInfo next = timerInfo.next;
                         timerInfo.prev = null;
                         timerInfo.next = null;
@@ -190,17 +192,17 @@ public void runInThreadPool()
                 }
                 else
                 {
-                    final long sleepTime = (firstEntry.getKey() - currentTime);
+                    final long waitTime = (firstEntry.getKey() - currentTime);
                     if (s_logger.isLoggable(Level.FINER))
-                        s_logger.log( Level.FINER, "firstEntry=" + firstEntry.getKey() + ", sleepTime=" + sleepTime );
+                        s_logger.log(Level.FINER, "firstEntry=" + firstEntry.getKey() + ", waitTime=" + waitTime);
 
                     try
                     {
-                        m_cond.awaitNanos( TimeUnit.MILLISECONDS.toNanos(sleepTime) );
+                        m_cond.awaitNanos(TimeUnit.MILLISECONDS.toNanos(waitTime));
                     }
                     catch (final InterruptedException ex)
                     {
-                        s_logger.warning( ex.toString() );
+                        s_logger.warning(ex.toString());
                     }
                 }
             }
@@ -211,10 +213,10 @@ public void runInThreadPool()
         }
 
         if (s_logger.isLoggable(Level.FINE))
-            s_logger.log( Level.FINE, "finished" );
+            s_logger.log(Level.FINE, "finished");
     }
 
-    private void removeTimerLocked( TimerInfo timerInfo )
+    private void removeTimerLocked(TimerInfo timerInfo)
     {
         boolean wakeUpThread = false;
 
@@ -227,7 +229,7 @@ private void removeTimerLocked( TimerInfo timerInfo )
             }
             else
             {
-                m_sortedTimers.put( timerInfo.fireTime, timerInfo.next );
+                m_sortedTimers.put(timerInfo.fireTime, timerInfo.next);
                 timerInfo.next = null;
             }
         }
@@ -279,40 +281,45 @@ public int schedule(Task task, long delay, TimeUnit unit)
                 return -1;
             }
 
-            final boolean wasEmpty = m_sortedTimers.isEmpty();
+            final Map.Entry<Long, TimerInfo> firstEntry = m_sortedTimers.firstEntry();
             final long fireTime = (System.currentTimeMillis() + unit.toMillis(delay));
-            final TimerInfo timerInfo = new TimerInfo( task );
-            timerInfo.fireTime = fireTime;
+            final TimerInfo timerInfo = new TimerInfo(task, fireTime);
 
-            final TimerInfo next = m_sortedTimers.get( fireTime );
+            final TimerInfo next = m_sortedTimers.get(fireTime);
             timerInfo.next = next;
             if (next != null)
                 next.prev = timerInfo;
 
-            m_sortedTimers.put( fireTime, timerInfo );
-            m_timers.put( task, timerInfo );
+            m_sortedTimers.put(fireTime, timerInfo);
+            m_timers.put(task, timerInfo);
 
-            if (wasEmpty)
+            if (firstEntry == null)
             {
                 if (s_logger.isLoggable(Level.FINER))
-                    s_logger.log( Level.FINER, System.identityHashCode(task) + ": fireTime=" + fireTime + ", start worker" );
-                m_threadPool.execute( this );
+                {
+                    s_logger.log(Level.FINER, System.identityHashCode(task)
+                            + ": fireTime=" + fireTime + ", start worker");
+                }
+                m_threadPool.execute(this);
             }
             else
             {
-                /* It make sense to wake up worker thread
+                /* It makes sense to wake up worker thread
                  * only if new timer is sooner than all previous.
                  */
-                if (fireTime < m_sortedTimers.firstKey())
+                if (fireTime < firstEntry.getKey())
                 {
                     if (s_logger.isLoggable(Level.FINER))
-                        s_logger.log( Level.FINER, System.identityHashCode(task) + ": firerTime=" + fireTime + ", wakeup worker" );
+                    {
+                        s_logger.log(Level.FINER, System.identityHashCode(task)
+                                + ": firerTime=" + fireTime + ", wakeup worker");
+                    }
                     m_cond.signal();
                 }
                 else
                 {
                     if (s_logger.isLoggable(Level.FINER))
-                        s_logger.log( Level.FINER, System.identityHashCode(task) + ": fireTime=" + fireTime );
+                        s_logger.log(Level.FINER, System.identityHashCode(task) + ": fireTime=" + fireTime);
                 }
             }
         }
@@ -339,16 +346,16 @@ public int cancel(Task task) throws InterruptedException
         {
             for (;;)
             {
-                final TimerInfo timerInfo = m_timers.get( task );
+                final TimerInfo timerInfo = m_timers.get(task);
                 if (timerInfo == null)
                 {
                     /* Timer already canceled or was not scheduled. */
                     if (s_logger.isLoggable( Level.FINER))
-                        s_logger.log( Level.FINER, System.identityHashCode(task) + ": not registered" );
+                        s_logger.log(Level.FINER, System.identityHashCode(task) + ": not registered");
                     return -1;
                 }
 
-                assert( timerInfo.task == task );
+                assert(timerInfo.task == task);
 
                 if (timerInfo.threadID == Thread.currentThread().getId())
                 {
@@ -359,18 +366,18 @@ else if (timerInfo.threadID == 0)
                 {
                     /* Timer is not fired yet */
                     if (s_logger.isLoggable( Level.FINER))
-                        s_logger.log( Level.FINER, System.identityHashCode(task) + ": canceled" );
+                        s_logger.log(Level.FINER, System.identityHashCode(task) + ": canceled");
                     removeTimerLocked( timerInfo );
                     return 0;
                 }
                 else if (timerInfo.threadID == -2)
                 {
                     /* Timer just fired */
                     if (s_logger.isLoggable(Level.FINER))
-                        s_logger.log( Level.FINER, System.identityHashCode(task) + ": canceled, just fired" );
-                    assert( timerInfo.cond != null );
+                        s_logger.log(Level.FINER, System.identityHashCode(task) + ": canceled, just fired");
+                    assert(timerInfo.cond != null);
                     timerInfo.cond = null;
-                    m_timers.remove( task );
+                    m_timers.remove(task);
                     return 0;
                 }
                 else
@@ -403,7 +410,7 @@ public int cancelNoWait(Task task)
         m_lock.lock();
         try
         {
-            final TimerInfo timerInfo = m_timers.get( task );
+            final TimerInfo timerInfo = m_timers.get(task);
             if (timerInfo == null)
             {
                 /* Timer already canceled or was not scheduled. */
@@ -416,12 +423,30 @@ public int cancelNoWait(Task task)
                 return 1;
             }
 
-            removeTimerLocked( timerInfo );
+            removeTimerLocked(timerInfo);
         }
         finally
         {
             m_lock.unlock();
         }
         return 0;
     }
+
+    /**
+     * Stop the timer queue.
+     */
+    public void stop()
+    {
+        m_lock.lock();
+        try
+        {
+            m_stop = true;
+            if (!m_timers.isEmpty())
+                m_cond.signal();
+        }
+        finally
+        {
+            m_lock.unlock();
+        }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@`
`40`	`40`
`41`	`41`	`public class TimerQueue extends ThreadPool.Runnable`
`42`	`42`	`{`
`43`		`- private static final Logger s_logger = Logger.getLogger( TimerQueue.class.getName() );`
	`43`	`+ private static final Logger s_logger = Logger.getLogger(TimerQueue.class.getName());`
`44`	`44`
`45`	`45`	`public interface Task`
`46`	`46`	`{`
`@@ -56,6 +56,7 @@ public interface Task`
`56`	`56`	`private final Condition m_cond;`
`57`	`57`	`private final TreeMap<Long, TimerInfo> m_sortedTimers;`
`58`	`58`	`private final Map<Task, TimerInfo> m_timers;`
	`59`	`+ private boolean m_stop;`
`59`	`60`
`60`	`61`	`private class TimerInfo extends ThreadPool.Runnable`
`61`	`62`	`{`
`@@ -66,23 +67,24 @@ private class TimerInfo extends ThreadPool.Runnable`
`66`	`67`	`public long threadID;`
`67`	`68`	`public Condition cond;`
`68`	`69`
`69`		`- public TimerInfo( Task task )`
	`70`	`+ public TimerInfo(Task task, long fireTime)`
`70`	`71`	`{`
`71`	`72`	`this.task = task;`
	`73`	`+ this.fireTime = fireTime;`
`72`	`74`	`}`
`73`	`75`
`74`	`76`	`public void runInThreadPool()`
`75`	`77`	`{`
`76`		`- assert( threadID == -1 );`
`77`		`- assert( prev == null );`
`78`		`- assert( next == null );`
	`78`	`+ assert(threadID == -1);`
	`79`	`+ assert(prev == null);`
	`80`	`+ assert(next == null);`
`79`	`81`	`threadID = Thread.currentThread().getId();`
`80`	`82`	`final long interval = task.run();`
`81`		`- restateTimer( this, interval );`
	`83`	`+ restateTimer(this, interval);`
`82`	`84`	`}`
`83`	`85`	`}`
`84`	`86`
`85`		`- private void restateTimer( TimerInfo timerInfo, long interval )`
	`87`	`+ private void restateTimer(TimerInfo timerInfo, long interval)`
`86`	`88`	`{`
`87`	`89`	`boolean snatchThread = false;`
`88`	`90`
`@@ -92,7 +94,7 @@ private void restateTimer( TimerInfo timerInfo, long interval )`
`92`	`94`	`if (timerInfo.cond != null)`
`93`	`95`	`{`
`94`	`96`	`if (s_logger.isLoggable(Level.FINER))`
`95`		`- s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) + ": pending cancel" );`
	`97`	`+ s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) + ": pending cancel");`
`96`	`98`
`97`	`99`	`timerInfo.threadID = -2;`
`98`	`100`	`timerInfo.cond.signalAll();`
`@@ -106,22 +108,22 @@ else if (interval > 0)`
`106`	`108`	`{`
`107`	`109`	`if (s_logger.isLoggable(Level.FINER))`
`108`	`110`	`{`
`109`		`- s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) +`
`110`		`- ": interval=" + interval + ", snatch thread" );`
	`111`	`+ s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) +`
	`112`	`+ ": interval=" + interval + ", snatch thread");`
`111`	`113`	`}`
`112`		`- m_sortedTimers.put( fireTime, timerInfo );`
	`114`	`+ m_sortedTimers.put(fireTime, timerInfo);`
`113`	`115`	`snatchThread = true;`
`114`	`116`	`}`
`115`	`117`	`else`
`116`	`118`	`{`
`117`		`- final TimerInfo next = m_sortedTimers.get( fireTime );`
`118`		`- m_sortedTimers.put( fireTime, timerInfo );`
	`119`	`+ final TimerInfo next = m_sortedTimers.get(fireTime);`
	`120`	`+ m_sortedTimers.put(fireTime, timerInfo);`
`119`	`121`	`if (next == null)`
`120`	`122`	`{`
`121`	`123`	`if (s_logger.isLoggable(Level.FINER))`
`122`	`124`	`{`
`123`		`- s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) +`
`124`		`- ": interval=" + interval + ", wakeup thread" );`
	`125`	`+ s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) +`
	`126`	`+ ": interval=" + interval + ", wakeup thread");`
`125`	`127`	`}`
`126`	`128`	`if (m_sortedTimers.firstKey() == fireTime)`
`127`	`129`	`m_cond.signal();`
`@@ -130,8 +132,8 @@ else if (interval > 0)`
`130`	`132`	`{`
`131`	`133`	`if (s_logger.isLoggable(Level.FINER))`
`132`	`134`	`{`
`133`		`- s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) +`
`134`		`- ": interval=" + interval );`
	`135`	`+ s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) +`
	`136`	`+ ": interval=" + interval);`
`135`	`137`	`}`
`136`	`138`	`timerInfo.next = next;`
`137`	`139`	`next.prev = timerInfo;`
`@@ -141,8 +143,8 @@ else if (interval > 0)`
`141`	`143`	`else`
`142`	`144`	`{`
`143`	`145`	`if (s_logger.isLoggable(Level.FINER))`
`144`		`- s_logger.log( Level.FINER, System.identityHashCode(timerInfo.task) + ": done" );`
`145`		`- m_timers.remove( timerInfo.task );`
	`146`	`+ s_logger.log(Level.FINER, System.identityHashCode(timerInfo.task) + ": done");`
	`147`	`+ m_timers.remove(timerInfo.task);`
`146`	`148`	`}`
`147`	`149`	`}`
`148`	`150`	`finally`
`@@ -162,21 +164,21 @@ public void runInThreadPool()`
`162`	`164`	`m_lock.lock();`
`163`	`165`	`try`
`164`	`166`	`{`
`165`		`- while (!m_sortedTimers.isEmpty())`
	`167`	`+ while (!m_sortedTimers.isEmpty() && !m_stop)`
`166`	`168`	`{`
`167`	`169`	`final Map.Entry<Long, TimerInfo> firstEntry = m_sortedTimers.firstEntry();`
`168`		`- assert( firstEntry != null );`
	`170`	`+ assert(firstEntry != null);`
`169`	`171`
`170`	`172`	`final long currentTime = System.currentTimeMillis();`
`171`	`173`	`if (firstEntry.getKey() <= currentTime)`
`172`	`174`	`{`
`173`	`175`	`if (s_logger.isLoggable(Level.FINER))`
`174`		`- s_logger.log( Level.FINER, "fireTime=" + firstEntry.getKey() + ": execute" );`
	`176`	`+ s_logger.log(Level.FINER, "fireTime=" + firstEntry.getKey() + ": execute");`
`175`	`177`
`176`	`178`	`TimerInfo timerInfo = firstEntry.getValue();`
`177`	`179`	`do`
`178`	`180`	`{`
`179`		`- assert( timerInfo.threadID == 0 );`
	`181`	`+ assert(timerInfo.threadID == 0);`
`180`	`182`	`final TimerInfo next = timerInfo.next;`
`181`	`183`	`timerInfo.prev = null;`
`182`	`184`	`timerInfo.next = null;`
`@@ -190,17 +192,17 @@ public void runInThreadPool()`
`190`	`192`	`}`
`191`	`193`	`else`
`192`	`194`	`{`
`193`		`- final long sleepTime = (firstEntry.getKey() - currentTime);`
	`195`	`+ final long waitTime = (firstEntry.getKey() - currentTime);`
`194`	`196`	`if (s_logger.isLoggable(Level.FINER))`
`195`		`- s_logger.log( Level.FINER, "firstEntry=" + firstEntry.getKey() + ", sleepTime=" + sleepTime );`
	`197`	`+ s_logger.log(Level.FINER, "firstEntry=" + firstEntry.getKey() + ", waitTime=" + waitTime);`
`196`	`198`
`197`	`199`	`try`
`198`	`200`	`{`
`199`		`- m_cond.awaitNanos( TimeUnit.MILLISECONDS.toNanos(sleepTime) );`
	`201`	`+ m_cond.awaitNanos(TimeUnit.MILLISECONDS.toNanos(waitTime));`
`200`	`202`	`}`
`201`	`203`	`catch (final InterruptedException ex)`
`202`	`204`	`{`
`203`		`- s_logger.warning( ex.toString() );`
	`205`	`+ s_logger.warning(ex.toString());`
`204`	`206`	`}`
`205`	`207`	`}`
`206`	`208`	`}`
`@@ -211,10 +213,10 @@ public void runInThreadPool()`
`211`	`213`	`}`
`212`	`214`
`213`	`215`	`if (s_logger.isLoggable(Level.FINE))`
`214`		`- s_logger.log( Level.FINE, "finished" );`
	`216`	`+ s_logger.log(Level.FINE, "finished");`
`215`	`217`	`}`
`216`	`218`
`217`		`- private void removeTimerLocked( TimerInfo timerInfo )`
	`219`	`+ private void removeTimerLocked(TimerInfo timerInfo)`
`218`	`220`	`{`
`219`	`221`	`boolean wakeUpThread = false;`
`220`	`222`
`@@ -227,7 +229,7 @@ private void removeTimerLocked( TimerInfo timerInfo )`
`227`	`229`	`}`
`228`	`230`	`else`
`229`	`231`	`{`
`230`		`- m_sortedTimers.put( timerInfo.fireTime, timerInfo.next );`
	`232`	`+ m_sortedTimers.put(timerInfo.fireTime, timerInfo.next);`
`231`	`233`	`timerInfo.next = null;`
`232`	`234`	`}`
`233`	`235`	`}`
`@@ -279,40 +281,45 @@ public int schedule(Task task, long delay, TimeUnit unit)`
`279`	`281`	`return -1;`
`280`	`282`	`}`
`281`	`283`
`282`		`- final boolean wasEmpty = m_sortedTimers.isEmpty();`
	`284`	`+ final Map.Entry<Long, TimerInfo> firstEntry = m_sortedTimers.firstEntry();`
`283`	`285`	`final long fireTime = (System.currentTimeMillis() + unit.toMillis(delay));`
`284`		`- final TimerInfo timerInfo = new TimerInfo( task );`
`285`		`- timerInfo.fireTime = fireTime;`
	`286`	`+ final TimerInfo timerInfo = new TimerInfo(task, fireTime);`
`286`	`287`
`287`		`- final TimerInfo next = m_sortedTimers.get( fireTime );`
	`288`	`+ final TimerInfo next = m_sortedTimers.get(fireTime);`
`288`	`289`	`timerInfo.next = next;`
`289`	`290`	`if (next != null)`
`290`	`291`	`next.prev = timerInfo;`
`291`	`292`
`292`		`- m_sortedTimers.put( fireTime, timerInfo );`
`293`		`- m_timers.put( task, timerInfo );`
	`293`	`+ m_sortedTimers.put(fireTime, timerInfo);`
	`294`	`+ m_timers.put(task, timerInfo);`
`294`	`295`
`295`		`- if (wasEmpty)`
	`296`	`+ if (firstEntry == null)`
`296`	`297`	`{`
`297`	`298`	`if (s_logger.isLoggable(Level.FINER))`
`298`		`- s_logger.log( Level.FINER, System.identityHashCode(task) + ": fireTime=" + fireTime + ", start worker" );`
`299`		`- m_threadPool.execute( this );`
	`299`	`+ {`
	`300`	`+ s_logger.log(Level.FINER, System.identityHashCode(task)`
	`301`	`+ + ": fireTime=" + fireTime + ", start worker");`
	`302`	`+ }`
	`303`	`+ m_threadPool.execute(this);`
`300`	`304`	`}`
`301`	`305`	`else`
`302`	`306`	`{`
`303`		`- /* It make sense to wake up worker thread`
	`307`	`+ /* It makes sense to wake up worker thread`
`304`	`308`	`* only if new timer is sooner than all previous.`
`305`	`309`	`*/`
`306`		`- if (fireTime < m_sortedTimers.firstKey())`
	`310`	`+ if (fireTime < firstEntry.getKey())`
`307`	`311`	`{`
`308`	`312`	`if (s_logger.isLoggable(Level.FINER))`
`309`		`- s_logger.log( Level.FINER, System.identityHashCode(task) + ": firerTime=" + fireTime + ", wakeup worker" );`
	`313`	`+ {`
	`314`	`+ s_logger.log(Level.FINER, System.identityHashCode(task)`
	`315`	`+ + ": firerTime=" + fireTime + ", wakeup worker");`
	`316`	`+ }`
`310`	`317`	`m_cond.signal();`
`311`	`318`	`}`
`312`	`319`	`else`
`313`	`320`	`{`
`314`	`321`	`if (s_logger.isLoggable(Level.FINER))`
`315`		`- s_logger.log( Level.FINER, System.identityHashCode(task) + ": fireTime=" + fireTime );`
	`322`	`+ s_logger.log(Level.FINER, System.identityHashCode(task) + ": fireTime=" + fireTime);`
`316`	`323`	`}`
`317`	`324`	`}`
`318`	`325`	`}`
`@@ -339,16 +346,16 @@ public int cancel(Task task) throws InterruptedException`
`339`	`346`	`{`
`340`	`347`	`for (;;)`
`341`	`348`	`{`
`342`		`- final TimerInfo timerInfo = m_timers.get( task );`
	`349`	`+ final TimerInfo timerInfo = m_timers.get(task);`
`343`	`350`	`if (timerInfo == null)`
`344`	`351`	`{`
`345`	`352`	`/* Timer already canceled or was not scheduled. */`
`346`	`353`	`if (s_logger.isLoggable( Level.FINER))`
`347`		`- s_logger.log( Level.FINER, System.identityHashCode(task) + ": not registered" );`
	`354`	`+ s_logger.log(Level.FINER, System.identityHashCode(task) + ": not registered");`
`348`	`355`	`return -1;`
`349`	`356`	`}`
`350`	`357`
`351`		`- assert( timerInfo.task == task );`
	`358`	`+ assert(timerInfo.task == task);`
`352`	`359`
`353`	`360`	`if (timerInfo.threadID == Thread.currentThread().getId())`
`354`	`361`	`{`
`@@ -359,18 +366,18 @@ else if (timerInfo.threadID == 0)`
`359`	`366`	`{`
`360`	`367`	`/* Timer is not fired yet */`
`361`	`368`	`if (s_logger.isLoggable( Level.FINER))`
`362`		`- s_logger.log( Level.FINER, System.identityHashCode(task) + ": canceled" );`
	`369`	`+ s_logger.log(Level.FINER, System.identityHashCode(task) + ": canceled");`
`363`	`370`	`removeTimerLocked( timerInfo );`
`364`	`371`	`return 0;`
`365`	`372`	`}`
`366`	`373`	`else if (timerInfo.threadID == -2)`
`367`	`374`	`{`
`368`	`375`	`/* Timer just fired */`
`369`	`376`	`if (s_logger.isLoggable(Level.FINER))`
`370`		`- s_logger.log( Level.FINER, System.identityHashCode(task) + ": canceled, just fired" );`
`371`		`- assert( timerInfo.cond != null );`
	`377`	`+ s_logger.log(Level.FINER, System.identityHashCode(task) + ": canceled, just fired");`
	`378`	`+ assert(timerInfo.cond != null);`
`372`	`379`	`timerInfo.cond = null;`
`373`		`- m_timers.remove( task );`
	`380`	`+ m_timers.remove(task);`
`374`	`381`	`return 0;`
`375`	`382`	`}`
`376`	`383`	`else`
`@@ -403,7 +410,7 @@ public int cancelNoWait(Task task)`
`403`	`410`	`m_lock.lock();`
`404`	`411`	`try`
`405`	`412`	`{`
`406`		`- final TimerInfo timerInfo = m_timers.get( task );`
	`413`	`+ final TimerInfo timerInfo = m_timers.get(task);`
`407`	`414`	`if (timerInfo == null)`
`408`	`415`	`{`
`409`	`416`	`/* Timer already canceled or was not scheduled. */`
`@@ -416,12 +423,30 @@ public int cancelNoWait(Task task)`
`416`	`423`	`return 1;`
`417`	`424`	`}`
`418`	`425`
`419`		`- removeTimerLocked( timerInfo );`
	`426`	`+ removeTimerLocked(timerInfo);`
`420`	`427`	`}`
`421`	`428`	`finally`
`422`	`429`	`{`
`423`	`430`	`m_lock.unlock();`
`424`	`431`	`}`
`425`	`432`	`return 0;`
`426`	`433`	`}`
	`434`	`+`
	`435`	`+ /**`
	`436`	`+ * Stop the timer queue.`
	`437`	`+ */`
	`438`	`+ public void stop()`
	`439`	`+ {`
	`440`	`+ m_lock.lock();`
	`441`	`+ try`
	`442`	`+ {`
	`443`	`+ m_stop = true;`
	`444`	`+ if (!m_timers.isEmpty())`
	`445`	`+ m_cond.signal();`
	`446`	`+ }`
	`447`	`+ finally`
	`448`	`+ {`
	`449`	`+ m_lock.unlock();`
	`450`	`+ }`
	`451`	`+ }`
`427`	`452`	`}`