Merging in timer
authorJaroslav Tulach <jtulach@netbeans.org>
Sat, 02 Nov 2013 16:43:48 +0100
changeset 1406161772460817
parent 1404 60ca4f72a70c
parent 1405 f8f4cf9046fd
child 1407 32e050a07754
Merging in timer
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/rt/emul/compact/src/main/java/java/util/Timer.java	Sat Nov 02 16:43:48 2013 +0100
     1.3 @@ -0,0 +1,720 @@
     1.4 +/*
     1.5 + * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
     1.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     1.7 + *
     1.8 + * This code is free software; you can redistribute it and/or modify it
     1.9 + * under the terms of the GNU General Public License version 2 only, as
    1.10 + * published by the Free Software Foundation.  Oracle designates this
    1.11 + * particular file as subject to the "Classpath" exception as provided
    1.12 + * by Oracle in the LICENSE file that accompanied this code.
    1.13 + *
    1.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    1.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    1.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    1.17 + * version 2 for more details (a copy is included in the LICENSE file that
    1.18 + * accompanied this code).
    1.19 + *
    1.20 + * You should have received a copy of the GNU General Public License version
    1.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    1.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    1.23 + *
    1.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    1.25 + * or visit www.oracle.com if you need additional information or have any
    1.26 + * questions.
    1.27 + */
    1.28 +
    1.29 +package java.util;
    1.30 +import java.util.Date;
    1.31 +import java.util.concurrent.atomic.AtomicInteger;
    1.32 +
    1.33 +/**
    1.34 + * A facility for threads to schedule tasks for future execution in a
    1.35 + * background thread.  Tasks may be scheduled for one-time execution, or for
    1.36 + * repeated execution at regular intervals.
    1.37 + *
    1.38 + * <p>Corresponding to each <tt>Timer</tt> object is a single background
    1.39 + * thread that is used to execute all of the timer's tasks, sequentially.
    1.40 + * Timer tasks should complete quickly.  If a timer task takes excessive time
    1.41 + * to complete, it "hogs" the timer's task execution thread.  This can, in
    1.42 + * turn, delay the execution of subsequent tasks, which may "bunch up" and
    1.43 + * execute in rapid succession when (and if) the offending task finally
    1.44 + * completes.
    1.45 + *
    1.46 + * <p>After the last live reference to a <tt>Timer</tt> object goes away
    1.47 + * <i>and</i> all outstanding tasks have completed execution, the timer's task
    1.48 + * execution thread terminates gracefully (and becomes subject to garbage
    1.49 + * collection).  However, this can take arbitrarily long to occur.  By
    1.50 + * default, the task execution thread does not run as a <i>daemon thread</i>,
    1.51 + * so it is capable of keeping an application from terminating.  If a caller
    1.52 + * wants to terminate a timer's task execution thread rapidly, the caller
    1.53 + * should invoke the timer's <tt>cancel</tt> method.
    1.54 + *
    1.55 + * <p>If the timer's task execution thread terminates unexpectedly, for
    1.56 + * example, because its <tt>stop</tt> method is invoked, any further
    1.57 + * attempt to schedule a task on the timer will result in an
    1.58 + * <tt>IllegalStateException</tt>, as if the timer's <tt>cancel</tt>
    1.59 + * method had been invoked.
    1.60 + *
    1.61 + * <p>This class is thread-safe: multiple threads can share a single
    1.62 + * <tt>Timer</tt> object without the need for external synchronization.
    1.63 + *
    1.64 + * <p>This class does <i>not</i> offer real-time guarantees: it schedules
    1.65 + * tasks using the <tt>Object.wait(long)</tt> method.
    1.66 + *
    1.67 + * <p>Java 5.0 introduced the {@code java.util.concurrent} package and
    1.68 + * one of the concurrency utilities therein is the {@link
    1.69 + * java.util.concurrent.ScheduledThreadPoolExecutor
    1.70 + * ScheduledThreadPoolExecutor} which is a thread pool for repeatedly
    1.71 + * executing tasks at a given rate or delay.  It is effectively a more
    1.72 + * versatile replacement for the {@code Timer}/{@code TimerTask}
    1.73 + * combination, as it allows multiple service threads, accepts various
    1.74 + * time units, and doesn't require subclassing {@code TimerTask} (just
    1.75 + * implement {@code Runnable}).  Configuring {@code
    1.76 + * ScheduledThreadPoolExecutor} with one thread makes it equivalent to
    1.77 + * {@code Timer}.
    1.78 + *
    1.79 + * <p>Implementation note: This class scales to large numbers of concurrently
    1.80 + * scheduled tasks (thousands should present no problem).  Internally,
    1.81 + * it uses a binary heap to represent its task queue, so the cost to schedule
    1.82 + * a task is O(log n), where n is the number of concurrently scheduled tasks.
    1.83 + *
    1.84 + * <p>Implementation note: All constructors start a timer thread.
    1.85 + *
    1.86 + * @author  Josh Bloch
    1.87 + * @see     TimerTask
    1.88 + * @see     Object#wait(long)
    1.89 + * @since   1.3
    1.90 + */
    1.91 +
    1.92 +public class Timer {
    1.93 +    /**
    1.94 +     * The timer task queue.  This data structure is shared with the timer
    1.95 +     * thread.  The timer produces tasks, via its various schedule calls,
    1.96 +     * and the timer thread consumes, executing timer tasks as appropriate,
    1.97 +     * and removing them from the queue when they're obsolete.
    1.98 +     */
    1.99 +    private final TaskQueue queue = new TaskQueue();
   1.100 +
   1.101 +    /**
   1.102 +     * The timer thread.
   1.103 +     */
   1.104 +    private final TimerThread thread = new TimerThread(queue);
   1.105 +
   1.106 +    /**
   1.107 +     * This object causes the timer's task execution thread to exit
   1.108 +     * gracefully when there are no live references to the Timer object and no
   1.109 +     * tasks in the timer queue.  It is used in preference to a finalizer on
   1.110 +     * Timer as such a finalizer would be susceptible to a subclass's
   1.111 +     * finalizer forgetting to call it.
   1.112 +     */
   1.113 +    private final Object threadReaper = new Object() {
   1.114 +        protected void finalize() throws Throwable {
   1.115 +            synchronized(queue) {
   1.116 +                thread.newTasksMayBeScheduled = false;
   1.117 +                queue.notify(); // In case queue is empty.
   1.118 +            }
   1.119 +        }
   1.120 +    };
   1.121 +
   1.122 +    /**
   1.123 +     * This ID is used to generate thread names.
   1.124 +     */
   1.125 +    private final static AtomicInteger nextSerialNumber = new AtomicInteger(0);
   1.126 +    private static int serialNumber() {
   1.127 +        return nextSerialNumber.getAndIncrement();
   1.128 +    }
   1.129 +
   1.130 +    /**
   1.131 +     * Creates a new timer.  The associated thread does <i>not</i>
   1.132 +     * {@linkplain Thread#setDaemon run as a daemon}.
   1.133 +     */
   1.134 +    public Timer() {
   1.135 +        this("Timer-" + serialNumber());
   1.136 +    }
   1.137 +
   1.138 +    /**
   1.139 +     * Creates a new timer whose associated thread may be specified to
   1.140 +     * {@linkplain Thread#setDaemon run as a daemon}.
   1.141 +     * A daemon thread is called for if the timer will be used to
   1.142 +     * schedule repeating "maintenance activities", which must be
   1.143 +     * performed as long as the application is running, but should not
   1.144 +     * prolong the lifetime of the application.
   1.145 +     *
   1.146 +     * @param isDaemon true if the associated thread should run as a daemon.
   1.147 +     */
   1.148 +    public Timer(boolean isDaemon) {
   1.149 +        this("Timer-" + serialNumber(), isDaemon);
   1.150 +    }
   1.151 +
   1.152 +    /**
   1.153 +     * Creates a new timer whose associated thread has the specified name.
   1.154 +     * The associated thread does <i>not</i>
   1.155 +     * {@linkplain Thread#setDaemon run as a daemon}.
   1.156 +     *
   1.157 +     * @param name the name of the associated thread
   1.158 +     * @throws NullPointerException if {@code name} is null
   1.159 +     * @since 1.5
   1.160 +     */
   1.161 +    public Timer(String name) {
   1.162 +        thread.setName(name);
   1.163 +        thread.start();
   1.164 +    }
   1.165 +
   1.166 +    /**
   1.167 +     * Creates a new timer whose associated thread has the specified name,
   1.168 +     * and may be specified to
   1.169 +     * {@linkplain Thread#setDaemon run as a daemon}.
   1.170 +     *
   1.171 +     * @param name the name of the associated thread
   1.172 +     * @param isDaemon true if the associated thread should run as a daemon
   1.173 +     * @throws NullPointerException if {@code name} is null
   1.174 +     * @since 1.5
   1.175 +     */
   1.176 +    public Timer(String name, boolean isDaemon) {
   1.177 +        thread.setName(name);
   1.178 +        thread.setDaemon(isDaemon);
   1.179 +        thread.start();
   1.180 +    }
   1.181 +
   1.182 +    /**
   1.183 +     * Schedules the specified task for execution after the specified delay.
   1.184 +     *
   1.185 +     * @param task  task to be scheduled.
   1.186 +     * @param delay delay in milliseconds before task is to be executed.
   1.187 +     * @throws IllegalArgumentException if <tt>delay</tt> is negative, or
   1.188 +     *         <tt>delay + System.currentTimeMillis()</tt> is negative.
   1.189 +     * @throws IllegalStateException if task was already scheduled or
   1.190 +     *         cancelled, timer was cancelled, or timer thread terminated.
   1.191 +     * @throws NullPointerException if {@code task} is null
   1.192 +     */
   1.193 +    public void schedule(TimerTask task, long delay) {
   1.194 +        if (delay < 0)
   1.195 +            throw new IllegalArgumentException("Negative delay.");
   1.196 +        sched(task, System.currentTimeMillis()+delay, 0);
   1.197 +    }
   1.198 +
   1.199 +    /**
   1.200 +     * Schedules the specified task for execution at the specified time.  If
   1.201 +     * the time is in the past, the task is scheduled for immediate execution.
   1.202 +     *
   1.203 +     * @param task task to be scheduled.
   1.204 +     * @param time time at which task is to be executed.
   1.205 +     * @throws IllegalArgumentException if <tt>time.getTime()</tt> is negative.
   1.206 +     * @throws IllegalStateException if task was already scheduled or
   1.207 +     *         cancelled, timer was cancelled, or timer thread terminated.
   1.208 +     * @throws NullPointerException if {@code task} or {@code time} is null
   1.209 +     */
   1.210 +    public void schedule(TimerTask task, Date time) {
   1.211 +        sched(task, time.getTime(), 0);
   1.212 +    }
   1.213 +
   1.214 +    /**
   1.215 +     * Schedules the specified task for repeated <i>fixed-delay execution</i>,
   1.216 +     * beginning after the specified delay.  Subsequent executions take place
   1.217 +     * at approximately regular intervals separated by the specified period.
   1.218 +     *
   1.219 +     * <p>In fixed-delay execution, each execution is scheduled relative to
   1.220 +     * the actual execution time of the previous execution.  If an execution
   1.221 +     * is delayed for any reason (such as garbage collection or other
   1.222 +     * background activity), subsequent executions will be delayed as well.
   1.223 +     * In the long run, the frequency of execution will generally be slightly
   1.224 +     * lower than the reciprocal of the specified period (assuming the system
   1.225 +     * clock underlying <tt>Object.wait(long)</tt> is accurate).
   1.226 +     *
   1.227 +     * <p>Fixed-delay execution is appropriate for recurring activities
   1.228 +     * that require "smoothness."  In other words, it is appropriate for
   1.229 +     * activities where it is more important to keep the frequency accurate
   1.230 +     * in the short run than in the long run.  This includes most animation
   1.231 +     * tasks, such as blinking a cursor at regular intervals.  It also includes
   1.232 +     * tasks wherein regular activity is performed in response to human
   1.233 +     * input, such as automatically repeating a character as long as a key
   1.234 +     * is held down.
   1.235 +     *
   1.236 +     * @param task   task to be scheduled.
   1.237 +     * @param delay  delay in milliseconds before task is to be executed.
   1.238 +     * @param period time in milliseconds between successive task executions.
   1.239 +     * @throws IllegalArgumentException if {@code delay < 0}, or
   1.240 +     *         {@code delay + System.currentTimeMillis() < 0}, or
   1.241 +     *         {@code period <= 0}
   1.242 +     * @throws IllegalStateException if task was already scheduled or
   1.243 +     *         cancelled, timer was cancelled, or timer thread terminated.
   1.244 +     * @throws NullPointerException if {@code task} is null
   1.245 +     */
   1.246 +    public void schedule(TimerTask task, long delay, long period) {
   1.247 +        if (delay < 0)
   1.248 +            throw new IllegalArgumentException("Negative delay.");
   1.249 +        if (period <= 0)
   1.250 +            throw new IllegalArgumentException("Non-positive period.");
   1.251 +        sched(task, System.currentTimeMillis()+delay, -period);
   1.252 +    }
   1.253 +
   1.254 +    /**
   1.255 +     * Schedules the specified task for repeated <i>fixed-delay execution</i>,
   1.256 +     * beginning at the specified time. Subsequent executions take place at
   1.257 +     * approximately regular intervals, separated by the specified period.
   1.258 +     *
   1.259 +     * <p>In fixed-delay execution, each execution is scheduled relative to
   1.260 +     * the actual execution time of the previous execution.  If an execution
   1.261 +     * is delayed for any reason (such as garbage collection or other
   1.262 +     * background activity), subsequent executions will be delayed as well.
   1.263 +     * In the long run, the frequency of execution will generally be slightly
   1.264 +     * lower than the reciprocal of the specified period (assuming the system
   1.265 +     * clock underlying <tt>Object.wait(long)</tt> is accurate).  As a
   1.266 +     * consequence of the above, if the scheduled first time is in the past,
   1.267 +     * it is scheduled for immediate execution.
   1.268 +     *
   1.269 +     * <p>Fixed-delay execution is appropriate for recurring activities
   1.270 +     * that require "smoothness."  In other words, it is appropriate for
   1.271 +     * activities where it is more important to keep the frequency accurate
   1.272 +     * in the short run than in the long run.  This includes most animation
   1.273 +     * tasks, such as blinking a cursor at regular intervals.  It also includes
   1.274 +     * tasks wherein regular activity is performed in response to human
   1.275 +     * input, such as automatically repeating a character as long as a key
   1.276 +     * is held down.
   1.277 +     *
   1.278 +     * @param task   task to be scheduled.
   1.279 +     * @param firstTime First time at which task is to be executed.
   1.280 +     * @param period time in milliseconds between successive task executions.
   1.281 +     * @throws IllegalArgumentException if {@code firstTime.getTime() < 0}, or
   1.282 +     *         {@code period <= 0}
   1.283 +     * @throws IllegalStateException if task was already scheduled or
   1.284 +     *         cancelled, timer was cancelled, or timer thread terminated.
   1.285 +     * @throws NullPointerException if {@code task} or {@code firstTime} is null
   1.286 +     */
   1.287 +    public void schedule(TimerTask task, Date firstTime, long period) {
   1.288 +        if (period <= 0)
   1.289 +            throw new IllegalArgumentException("Non-positive period.");
   1.290 +        sched(task, firstTime.getTime(), -period);
   1.291 +    }
   1.292 +
   1.293 +    /**
   1.294 +     * Schedules the specified task for repeated <i>fixed-rate execution</i>,
   1.295 +     * beginning after the specified delay.  Subsequent executions take place
   1.296 +     * at approximately regular intervals, separated by the specified period.
   1.297 +     *
   1.298 +     * <p>In fixed-rate execution, each execution is scheduled relative to the
   1.299 +     * scheduled execution time of the initial execution.  If an execution is
   1.300 +     * delayed for any reason (such as garbage collection or other background
   1.301 +     * activity), two or more executions will occur in rapid succession to
   1.302 +     * "catch up."  In the long run, the frequency of execution will be
   1.303 +     * exactly the reciprocal of the specified period (assuming the system
   1.304 +     * clock underlying <tt>Object.wait(long)</tt> is accurate).
   1.305 +     *
   1.306 +     * <p>Fixed-rate execution is appropriate for recurring activities that
   1.307 +     * are sensitive to <i>absolute</i> time, such as ringing a chime every
   1.308 +     * hour on the hour, or running scheduled maintenance every day at a
   1.309 +     * particular time.  It is also appropriate for recurring activities
   1.310 +     * where the total time to perform a fixed number of executions is
   1.311 +     * important, such as a countdown timer that ticks once every second for
   1.312 +     * ten seconds.  Finally, fixed-rate execution is appropriate for
   1.313 +     * scheduling multiple repeating timer tasks that must remain synchronized
   1.314 +     * with respect to one another.
   1.315 +     *
   1.316 +     * @param task   task to be scheduled.
   1.317 +     * @param delay  delay in milliseconds before task is to be executed.
   1.318 +     * @param period time in milliseconds between successive task executions.
   1.319 +     * @throws IllegalArgumentException if {@code delay < 0}, or
   1.320 +     *         {@code delay + System.currentTimeMillis() < 0}, or
   1.321 +     *         {@code period <= 0}
   1.322 +     * @throws IllegalStateException if task was already scheduled or
   1.323 +     *         cancelled, timer was cancelled, or timer thread terminated.
   1.324 +     * @throws NullPointerException if {@code task} is null
   1.325 +     */
   1.326 +    public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
   1.327 +        if (delay < 0)
   1.328 +            throw new IllegalArgumentException("Negative delay.");
   1.329 +        if (period <= 0)
   1.330 +            throw new IllegalArgumentException("Non-positive period.");
   1.331 +        sched(task, System.currentTimeMillis()+delay, period);
   1.332 +    }
   1.333 +
   1.334 +    /**
   1.335 +     * Schedules the specified task for repeated <i>fixed-rate execution</i>,
   1.336 +     * beginning at the specified time. Subsequent executions take place at
   1.337 +     * approximately regular intervals, separated by the specified period.
   1.338 +     *
   1.339 +     * <p>In fixed-rate execution, each execution is scheduled relative to the
   1.340 +     * scheduled execution time of the initial execution.  If an execution is
   1.341 +     * delayed for any reason (such as garbage collection or other background
   1.342 +     * activity), two or more executions will occur in rapid succession to
   1.343 +     * "catch up."  In the long run, the frequency of execution will be
   1.344 +     * exactly the reciprocal of the specified period (assuming the system
   1.345 +     * clock underlying <tt>Object.wait(long)</tt> is accurate).  As a
   1.346 +     * consequence of the above, if the scheduled first time is in the past,
   1.347 +     * then any "missed" executions will be scheduled for immediate "catch up"
   1.348 +     * execution.
   1.349 +     *
   1.350 +     * <p>Fixed-rate execution is appropriate for recurring activities that
   1.351 +     * are sensitive to <i>absolute</i> time, such as ringing a chime every
   1.352 +     * hour on the hour, or running scheduled maintenance every day at a
   1.353 +     * particular time.  It is also appropriate for recurring activities
   1.354 +     * where the total time to perform a fixed number of executions is
   1.355 +     * important, such as a countdown timer that ticks once every second for
   1.356 +     * ten seconds.  Finally, fixed-rate execution is appropriate for
   1.357 +     * scheduling multiple repeating timer tasks that must remain synchronized
   1.358 +     * with respect to one another.
   1.359 +     *
   1.360 +     * @param task   task to be scheduled.
   1.361 +     * @param firstTime First time at which task is to be executed.
   1.362 +     * @param period time in milliseconds between successive task executions.
   1.363 +     * @throws IllegalArgumentException if {@code firstTime.getTime() < 0} or
   1.364 +     *         {@code period <= 0}
   1.365 +     * @throws IllegalStateException if task was already scheduled or
   1.366 +     *         cancelled, timer was cancelled, or timer thread terminated.
   1.367 +     * @throws NullPointerException if {@code task} or {@code firstTime} is null
   1.368 +     */
   1.369 +    public void scheduleAtFixedRate(TimerTask task, Date firstTime,
   1.370 +                                    long period) {
   1.371 +        if (period <= 0)
   1.372 +            throw new IllegalArgumentException("Non-positive period.");
   1.373 +        sched(task, firstTime.getTime(), period);
   1.374 +    }
   1.375 +
   1.376 +    /**
   1.377 +     * Schedule the specified timer task for execution at the specified
   1.378 +     * time with the specified period, in milliseconds.  If period is
   1.379 +     * positive, the task is scheduled for repeated execution; if period is
   1.380 +     * zero, the task is scheduled for one-time execution. Time is specified
   1.381 +     * in Date.getTime() format.  This method checks timer state, task state,
   1.382 +     * and initial execution time, but not period.
   1.383 +     *
   1.384 +     * @throws IllegalArgumentException if <tt>time</tt> is negative.
   1.385 +     * @throws IllegalStateException if task was already scheduled or
   1.386 +     *         cancelled, timer was cancelled, or timer thread terminated.
   1.387 +     * @throws NullPointerException if {@code task} is null
   1.388 +     */
   1.389 +    private void sched(TimerTask task, long time, long period) {
   1.390 +        if (time < 0)
   1.391 +            throw new IllegalArgumentException("Illegal execution time.");
   1.392 +
   1.393 +        // Constrain value of period sufficiently to prevent numeric
   1.394 +        // overflow while still being effectively infinitely large.
   1.395 +        if (Math.abs(period) > (Long.MAX_VALUE >> 1))
   1.396 +            period >>= 1;
   1.397 +
   1.398 +        synchronized(queue) {
   1.399 +            if (!thread.newTasksMayBeScheduled)
   1.400 +                throw new IllegalStateException("Timer already cancelled.");
   1.401 +
   1.402 +            synchronized(task.lock) {
   1.403 +                if (task.state != TimerTask.VIRGIN)
   1.404 +                    throw new IllegalStateException(
   1.405 +                        "Task already scheduled or cancelled");
   1.406 +                task.nextExecutionTime = time;
   1.407 +                task.period = period;
   1.408 +                task.state = TimerTask.SCHEDULED;
   1.409 +            }
   1.410 +
   1.411 +            queue.add(task);
   1.412 +            if (queue.getMin() == task)
   1.413 +                queue.notify();
   1.414 +        }
   1.415 +    }
   1.416 +
   1.417 +    /**
   1.418 +     * Terminates this timer, discarding any currently scheduled tasks.
   1.419 +     * Does not interfere with a currently executing task (if it exists).
   1.420 +     * Once a timer has been terminated, its execution thread terminates
   1.421 +     * gracefully, and no more tasks may be scheduled on it.
   1.422 +     *
   1.423 +     * <p>Note that calling this method from within the run method of a
   1.424 +     * timer task that was invoked by this timer absolutely guarantees that
   1.425 +     * the ongoing task execution is the last task execution that will ever
   1.426 +     * be performed by this timer.
   1.427 +     *
   1.428 +     * <p>This method may be called repeatedly; the second and subsequent
   1.429 +     * calls have no effect.
   1.430 +     */
   1.431 +    public void cancel() {
   1.432 +        synchronized(queue) {
   1.433 +            thread.newTasksMayBeScheduled = false;
   1.434 +            queue.clear();
   1.435 +            queue.notify();  // In case queue was already empty.
   1.436 +        }
   1.437 +    }
   1.438 +
   1.439 +    /**
   1.440 +     * Removes all cancelled tasks from this timer's task queue.  <i>Calling
   1.441 +     * this method has no effect on the behavior of the timer</i>, but
   1.442 +     * eliminates the references to the cancelled tasks from the queue.
   1.443 +     * If there are no external references to these tasks, they become
   1.444 +     * eligible for garbage collection.
   1.445 +     *
   1.446 +     * <p>Most programs will have no need to call this method.
   1.447 +     * It is designed for use by the rare application that cancels a large
   1.448 +     * number of tasks.  Calling this method trades time for space: the
   1.449 +     * runtime of the method may be proportional to n + c log n, where n
   1.450 +     * is the number of tasks in the queue and c is the number of cancelled
   1.451 +     * tasks.
   1.452 +     *
   1.453 +     * <p>Note that it is permissible to call this method from within a
   1.454 +     * a task scheduled on this timer.
   1.455 +     *
   1.456 +     * @return the number of tasks removed from the queue.
   1.457 +     * @since 1.5
   1.458 +     */
   1.459 +     public int purge() {
   1.460 +         int result = 0;
   1.461 +
   1.462 +         synchronized(queue) {
   1.463 +             for (int i = queue.size(); i > 0; i--) {
   1.464 +                 if (queue.get(i).state == TimerTask.CANCELLED) {
   1.465 +                     queue.quickRemove(i);
   1.466 +                     result++;
   1.467 +                 }
   1.468 +             }
   1.469 +
   1.470 +             if (result != 0)
   1.471 +                 queue.heapify();
   1.472 +         }
   1.473 +
   1.474 +         return result;
   1.475 +     }
   1.476 +}
   1.477 +
   1.478 +/**
   1.479 + * This "helper class" implements the timer's task execution thread, which
   1.480 + * waits for tasks on the timer queue, executions them when they fire,
   1.481 + * reschedules repeating tasks, and removes cancelled tasks and spent
   1.482 + * non-repeating tasks from the queue.
   1.483 + */
   1.484 +class TimerThread extends Thread {
   1.485 +    /**
   1.486 +     * This flag is set to false by the reaper to inform us that there
   1.487 +     * are no more live references to our Timer object.  Once this flag
   1.488 +     * is true and there are no more tasks in our queue, there is no
   1.489 +     * work left for us to do, so we terminate gracefully.  Note that
   1.490 +     * this field is protected by queue's monitor!
   1.491 +     */
   1.492 +    boolean newTasksMayBeScheduled = true;
   1.493 +
   1.494 +    /**
   1.495 +     * Our Timer's queue.  We store this reference in preference to
   1.496 +     * a reference to the Timer so the reference graph remains acyclic.
   1.497 +     * Otherwise, the Timer would never be garbage-collected and this
   1.498 +     * thread would never go away.
   1.499 +     */
   1.500 +    private TaskQueue queue;
   1.501 +
   1.502 +    TimerThread(TaskQueue queue) {
   1.503 +        this.queue = queue;
   1.504 +    }
   1.505 +
   1.506 +    public void run() {
   1.507 +        try {
   1.508 +            mainLoop();
   1.509 +        } finally {
   1.510 +            // Someone killed this Thread, behave as if Timer cancelled
   1.511 +            synchronized(queue) {
   1.512 +                newTasksMayBeScheduled = false;
   1.513 +                queue.clear();  // Eliminate obsolete references
   1.514 +            }
   1.515 +        }
   1.516 +    }
   1.517 +
   1.518 +    /**
   1.519 +     * The main timer loop.  (See class comment.)
   1.520 +     */
   1.521 +    private void mainLoop() {
   1.522 +        while (true) {
   1.523 +            try {
   1.524 +                TimerTask task;
   1.525 +                boolean taskFired;
   1.526 +                synchronized(queue) {
   1.527 +                    // Wait for queue to become non-empty
   1.528 +                    while (queue.isEmpty() && newTasksMayBeScheduled)
   1.529 +                        queue.wait();
   1.530 +                    if (queue.isEmpty())
   1.531 +                        break; // Queue is empty and will forever remain; die
   1.532 +
   1.533 +                    // Queue nonempty; look at first evt and do the right thing
   1.534 +                    long currentTime, executionTime;
   1.535 +                    task = queue.getMin();
   1.536 +                    synchronized(task.lock) {
   1.537 +                        if (task.state == TimerTask.CANCELLED) {
   1.538 +                            queue.removeMin();
   1.539 +                            continue;  // No action required, poll queue again
   1.540 +                        }
   1.541 +                        currentTime = System.currentTimeMillis();
   1.542 +                        executionTime = task.nextExecutionTime;
   1.543 +                        if (taskFired = (executionTime<=currentTime)) {
   1.544 +                            if (task.period == 0) { // Non-repeating, remove
   1.545 +                                queue.removeMin();
   1.546 +                                task.state = TimerTask.EXECUTED;
   1.547 +                            } else { // Repeating task, reschedule
   1.548 +                                queue.rescheduleMin(
   1.549 +                                  task.period<0 ? currentTime   - task.period
   1.550 +                                                : executionTime + task.period);
   1.551 +                            }
   1.552 +                        }
   1.553 +                    }
   1.554 +                    if (!taskFired) // Task hasn't yet fired; wait
   1.555 +                        queue.wait(executionTime - currentTime);
   1.556 +                }
   1.557 +                if (taskFired)  // Task fired; run it, holding no locks
   1.558 +                    task.run();
   1.559 +            } catch(InterruptedException e) {
   1.560 +            }
   1.561 +        }
   1.562 +    }
   1.563 +}
   1.564 +
   1.565 +/**
   1.566 + * This class represents a timer task queue: a priority queue of TimerTasks,
   1.567 + * ordered on nextExecutionTime.  Each Timer object has one of these, which it
   1.568 + * shares with its TimerThread.  Internally this class uses a heap, which
   1.569 + * offers log(n) performance for the add, removeMin and rescheduleMin
   1.570 + * operations, and constant time performance for the getMin operation.
   1.571 + */
   1.572 +class TaskQueue {
   1.573 +    /**
   1.574 +     * Priority queue represented as a balanced binary heap: the two children
   1.575 +     * of queue[n] are queue[2*n] and queue[2*n+1].  The priority queue is
   1.576 +     * ordered on the nextExecutionTime field: The TimerTask with the lowest
   1.577 +     * nextExecutionTime is in queue[1] (assuming the queue is nonempty).  For
   1.578 +     * each node n in the heap, and each descendant of n, d,
   1.579 +     * n.nextExecutionTime <= d.nextExecutionTime.
   1.580 +     */
   1.581 +    private TimerTask[] queue = new TimerTask[128];
   1.582 +
   1.583 +    /**
   1.584 +     * The number of tasks in the priority queue.  (The tasks are stored in
   1.585 +     * queue[1] up to queue[size]).
   1.586 +     */
   1.587 +    private int size = 0;
   1.588 +
   1.589 +    /**
   1.590 +     * Returns the number of tasks currently on the queue.
   1.591 +     */
   1.592 +    int size() {
   1.593 +        return size;
   1.594 +    }
   1.595 +
   1.596 +    /**
   1.597 +     * Adds a new task to the priority queue.
   1.598 +     */
   1.599 +    void add(TimerTask task) {
   1.600 +        // Grow backing store if necessary
   1.601 +        if (size + 1 == queue.length)
   1.602 +            queue = Arrays.copyOf(queue, 2*queue.length);
   1.603 +
   1.604 +        queue[++size] = task;
   1.605 +        fixUp(size);
   1.606 +    }
   1.607 +
   1.608 +    /**
   1.609 +     * Return the "head task" of the priority queue.  (The head task is an
   1.610 +     * task with the lowest nextExecutionTime.)
   1.611 +     */
   1.612 +    TimerTask getMin() {
   1.613 +        return queue[1];
   1.614 +    }
   1.615 +
   1.616 +    /**
   1.617 +     * Return the ith task in the priority queue, where i ranges from 1 (the
   1.618 +     * head task, which is returned by getMin) to the number of tasks on the
   1.619 +     * queue, inclusive.
   1.620 +     */
   1.621 +    TimerTask get(int i) {
   1.622 +        return queue[i];
   1.623 +    }
   1.624 +
   1.625 +    /**
   1.626 +     * Remove the head task from the priority queue.
   1.627 +     */
   1.628 +    void removeMin() {
   1.629 +        queue[1] = queue[size];
   1.630 +        queue[size--] = null;  // Drop extra reference to prevent memory leak
   1.631 +        fixDown(1);
   1.632 +    }
   1.633 +
   1.634 +    /**
   1.635 +     * Removes the ith element from queue without regard for maintaining
   1.636 +     * the heap invariant.  Recall that queue is one-based, so
   1.637 +     * 1 <= i <= size.
   1.638 +     */
   1.639 +    void quickRemove(int i) {
   1.640 +        assert i <= size;
   1.641 +
   1.642 +        queue[i] = queue[size];
   1.643 +        queue[size--] = null;  // Drop extra ref to prevent memory leak
   1.644 +    }
   1.645 +
   1.646 +    /**
   1.647 +     * Sets the nextExecutionTime associated with the head task to the
   1.648 +     * specified value, and adjusts priority queue accordingly.
   1.649 +     */
   1.650 +    void rescheduleMin(long newTime) {
   1.651 +        queue[1].nextExecutionTime = newTime;
   1.652 +        fixDown(1);
   1.653 +    }
   1.654 +
   1.655 +    /**
   1.656 +     * Returns true if the priority queue contains no elements.
   1.657 +     */
   1.658 +    boolean isEmpty() {
   1.659 +        return size==0;
   1.660 +    }
   1.661 +
   1.662 +    /**
   1.663 +     * Removes all elements from the priority queue.
   1.664 +     */
   1.665 +    void clear() {
   1.666 +        // Null out task references to prevent memory leak
   1.667 +        for (int i=1; i<=size; i++)
   1.668 +            queue[i] = null;
   1.669 +
   1.670 +        size = 0;
   1.671 +    }
   1.672 +
   1.673 +    /**
   1.674 +     * Establishes the heap invariant (described above) assuming the heap
   1.675 +     * satisfies the invariant except possibly for the leaf-node indexed by k
   1.676 +     * (which may have a nextExecutionTime less than its parent's).
   1.677 +     *
   1.678 +     * This method functions by "promoting" queue[k] up the hierarchy
   1.679 +     * (by swapping it with its parent) repeatedly until queue[k]'s
   1.680 +     * nextExecutionTime is greater than or equal to that of its parent.
   1.681 +     */
   1.682 +    private void fixUp(int k) {
   1.683 +        while (k > 1) {
   1.684 +            int j = k >> 1;
   1.685 +            if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
   1.686 +                break;
   1.687 +            TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
   1.688 +            k = j;
   1.689 +        }
   1.690 +    }
   1.691 +
   1.692 +    /**
   1.693 +     * Establishes the heap invariant (described above) in the subtree
   1.694 +     * rooted at k, which is assumed to satisfy the heap invariant except
   1.695 +     * possibly for node k itself (which may have a nextExecutionTime greater
   1.696 +     * than its children's).
   1.697 +     *
   1.698 +     * This method functions by "demoting" queue[k] down the hierarchy
   1.699 +     * (by swapping it with its smaller child) repeatedly until queue[k]'s
   1.700 +     * nextExecutionTime is less than or equal to those of its children.
   1.701 +     */
   1.702 +    private void fixDown(int k) {
   1.703 +        int j;
   1.704 +        while ((j = k << 1) <= size && j > 0) {
   1.705 +            if (j < size &&
   1.706 +                queue[j].nextExecutionTime > queue[j+1].nextExecutionTime)
   1.707 +                j++; // j indexes smallest kid
   1.708 +            if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
   1.709 +                break;
   1.710 +            TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
   1.711 +            k = j;
   1.712 +        }
   1.713 +    }
   1.714 +
   1.715 +    /**
   1.716 +     * Establishes the heap invariant (described above) in the entire tree,
   1.717 +     * assuming nothing about the order of the elements prior to the call.
   1.718 +     */
   1.719 +    void heapify() {
   1.720 +        for (int i = size/2; i >= 1; i--)
   1.721 +            fixDown(i);
   1.722 +    }
   1.723 +}
     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/rt/emul/compact/src/main/java/java/util/TimerTask.java	Sat Nov 02 16:43:48 2013 +0100
     2.3 @@ -0,0 +1,158 @@
     2.4 +/*
     2.5 + * Copyright (c) 1999, 2004, Oracle and/or its affiliates. All rights reserved.
     2.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     2.7 + *
     2.8 + * This code is free software; you can redistribute it and/or modify it
     2.9 + * under the terms of the GNU General Public License version 2 only, as
    2.10 + * published by the Free Software Foundation.  Oracle designates this
    2.11 + * particular file as subject to the "Classpath" exception as provided
    2.12 + * by Oracle in the LICENSE file that accompanied this code.
    2.13 + *
    2.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    2.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    2.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    2.17 + * version 2 for more details (a copy is included in the LICENSE file that
    2.18 + * accompanied this code).
    2.19 + *
    2.20 + * You should have received a copy of the GNU General Public License version
    2.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    2.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    2.23 + *
    2.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    2.25 + * or visit www.oracle.com if you need additional information or have any
    2.26 + * questions.
    2.27 + */
    2.28 +
    2.29 +package java.util;
    2.30 +
    2.31 +/**
    2.32 + * A task that can be scheduled for one-time or repeated execution by a Timer.
    2.33 + *
    2.34 + * @author  Josh Bloch
    2.35 + * @see     Timer
    2.36 + * @since   1.3
    2.37 + */
    2.38 +
    2.39 +public abstract class TimerTask implements Runnable {
    2.40 +    /**
    2.41 +     * This object is used to control access to the TimerTask internals.
    2.42 +     */
    2.43 +    final Object lock = new Object();
    2.44 +
    2.45 +    /**
    2.46 +     * The state of this task, chosen from the constants below.
    2.47 +     */
    2.48 +    int state = VIRGIN;
    2.49 +
    2.50 +    /**
    2.51 +     * This task has not yet been scheduled.
    2.52 +     */
    2.53 +    static final int VIRGIN = 0;
    2.54 +
    2.55 +    /**
    2.56 +     * This task is scheduled for execution.  If it is a non-repeating task,
    2.57 +     * it has not yet been executed.
    2.58 +     */
    2.59 +    static final int SCHEDULED   = 1;
    2.60 +
    2.61 +    /**
    2.62 +     * This non-repeating task has already executed (or is currently
    2.63 +     * executing) and has not been cancelled.
    2.64 +     */
    2.65 +    static final int EXECUTED    = 2;
    2.66 +
    2.67 +    /**
    2.68 +     * This task has been cancelled (with a call to TimerTask.cancel).
    2.69 +     */
    2.70 +    static final int CANCELLED   = 3;
    2.71 +
    2.72 +    /**
    2.73 +     * Next execution time for this task in the format returned by
    2.74 +     * System.currentTimeMillis, assuming this task is scheduled for execution.
    2.75 +     * For repeating tasks, this field is updated prior to each task execution.
    2.76 +     */
    2.77 +    long nextExecutionTime;
    2.78 +
    2.79 +    /**
    2.80 +     * Period in milliseconds for repeating tasks.  A positive value indicates
    2.81 +     * fixed-rate execution.  A negative value indicates fixed-delay execution.
    2.82 +     * A value of 0 indicates a non-repeating task.
    2.83 +     */
    2.84 +    long period = 0;
    2.85 +
    2.86 +    /**
    2.87 +     * Creates a new timer task.
    2.88 +     */
    2.89 +    protected TimerTask() {
    2.90 +    }
    2.91 +
    2.92 +    /**
    2.93 +     * The action to be performed by this timer task.
    2.94 +     */
    2.95 +    public abstract void run();
    2.96 +
    2.97 +    /**
    2.98 +     * Cancels this timer task.  If the task has been scheduled for one-time
    2.99 +     * execution and has not yet run, or has not yet been scheduled, it will
   2.100 +     * never run.  If the task has been scheduled for repeated execution, it
   2.101 +     * will never run again.  (If the task is running when this call occurs,
   2.102 +     * the task will run to completion, but will never run again.)
   2.103 +     *
   2.104 +     * <p>Note that calling this method from within the <tt>run</tt> method of
   2.105 +     * a repeating timer task absolutely guarantees that the timer task will
   2.106 +     * not run again.
   2.107 +     *
   2.108 +     * <p>This method may be called repeatedly; the second and subsequent
   2.109 +     * calls have no effect.
   2.110 +     *
   2.111 +     * @return true if this task is scheduled for one-time execution and has
   2.112 +     *         not yet run, or this task is scheduled for repeated execution.
   2.113 +     *         Returns false if the task was scheduled for one-time execution
   2.114 +     *         and has already run, or if the task was never scheduled, or if
   2.115 +     *         the task was already cancelled.  (Loosely speaking, this method
   2.116 +     *         returns <tt>true</tt> if it prevents one or more scheduled
   2.117 +     *         executions from taking place.)
   2.118 +     */
   2.119 +    public boolean cancel() {
   2.120 +        synchronized(lock) {
   2.121 +            boolean result = (state == SCHEDULED);
   2.122 +            state = CANCELLED;
   2.123 +            return result;
   2.124 +        }
   2.125 +    }
   2.126 +
   2.127 +    /**
   2.128 +     * Returns the <i>scheduled</i> execution time of the most recent
   2.129 +     * <i>actual</i> execution of this task.  (If this method is invoked
   2.130 +     * while task execution is in progress, the return value is the scheduled
   2.131 +     * execution time of the ongoing task execution.)
   2.132 +     *
   2.133 +     * <p>This method is typically invoked from within a task's run method, to
   2.134 +     * determine whether the current execution of the task is sufficiently
   2.135 +     * timely to warrant performing the scheduled activity:
   2.136 +     * <pre>
   2.137 +     *   public void run() {
   2.138 +     *       if (System.currentTimeMillis() - scheduledExecutionTime() >=
   2.139 +     *           MAX_TARDINESS)
   2.140 +     *               return;  // Too late; skip this execution.
   2.141 +     *       // Perform the task
   2.142 +     *   }
   2.143 +     * </pre>
   2.144 +     * This method is typically <i>not</i> used in conjunction with
   2.145 +     * <i>fixed-delay execution</i> repeating tasks, as their scheduled
   2.146 +     * execution times are allowed to drift over time, and so are not terribly
   2.147 +     * significant.
   2.148 +     *
   2.149 +     * @return the time at which the most recent execution of this task was
   2.150 +     *         scheduled to occur, in the format returned by Date.getTime().
   2.151 +     *         The return value is undefined if the task has yet to commence
   2.152 +     *         its first execution.
   2.153 +     * @see Date#getTime()
   2.154 +     */
   2.155 +    public long scheduledExecutionTime() {
   2.156 +        synchronized(lock) {
   2.157 +            return (period < 0 ? nextExecutionTime + period
   2.158 +                               : nextExecutionTime - period);
   2.159 +        }
   2.160 +    }
   2.161 +}