/*
* Written by Dawid Kurzyniec, based on code written by Doug Lea with assistance
* from members of JCP JSR-166 Expert Group. Released to the public domain,
* as explained at http://creativecommons.org/licenses/publicdomain.
*
* Thanks to Craig Mattocks for suggesting to use sun.misc.Perf
.
*/
package scala.actors.threadpool.helpers;
//import edu.emory.mathcs.backport.java.util.*;
import scala.actors.threadpool.*;
import scala.actors.threadpool.locks.*;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.lang.reflect.Array;
import java.util.Iterator;
import java.util.Collection;
/**
*
* This class groups together the functionality of java.util.concurrent that * cannot be fully and reliably implemented in backport, but for which some * form of emulation is possible. *
* Currently, this class contains methods related to nanosecond-precision
* timing, particularly via the {@link #nanoTime} method. To measure time
* accurately, this method by default uses
* Implementation note:By default, this method uses
*
* Note: on JDK 1.4.2, The lock associated with this condition is atomically
* released and the current thread becomes disabled for thread scheduling
* purposes and lies dormant until one of five things happens:
* In all cases, before this method can return the current thread must
* re-acquire the lock associated with this condition. When the
* thread returns it is guaranteed to hold this lock.
*
* If the current thread:
* The method returns an estimate of the number of nanoseconds
* remaining to wait given the supplied nanosTimeout
* value upon return, or a value less than or equal to zero if it
* timed out. Accuracy of this estimate is directly dependent on the
* accuracy of {@link #nanoTime}. This value can be used to determine
* whether and how long to re-wait in cases where the wait returns but an
* awaited condition still does not hold. Typical uses of this method take
* the following form:
*
* Implementation Considerations
* The current thread is assumed to hold the lock associated with this
* Condition when this method is called.
* It is up to the implementation to determine if this is
* the case and if not, how to respond. Typically, an exception will be
* thrown (such as {@link IllegalMonitorStateException}) and the
* implementation must document that fact.
*
* A condition implementation can favor responding to an interrupt over
* normal method return in response to a signal, or over indicating the
* elapse of the specified waiting time. In either case the implementation
* must ensure that the signal is redirected to another waiting thread, if
* there is one.
*
* @param cond the condition to wait for
* @param nanosTimeout the maximum time to wait, in nanoseconds
* @return A value less than or equal to zero if the wait has
* timed out; otherwise an estimate, that
* is strictly less than the nanosTimeout argument,
* of the time still remaining when this method returned.
*
* @throws InterruptedException if the current thread is interrupted (and
* interruption of thread suspension is supported).
*/
public static long awaitNanos(Condition cond, long nanosTimeout)
throws InterruptedException
{
if (nanosTimeout <= 0) return nanosTimeout;
long now = nanoTime();
cond.await(nanosTimeout, TimeUnit.NANOSECONDS);
return nanosTimeout - (nanoTime() - now);
}
private static final class SunPerfProvider implements NanoTimer {
final Perf perf;
final long multiplier, divisor;
SunPerfProvider() {
perf =
AccessController.doPrivileged(new PrivilegedActionjava.sun.Perf
on
* JDK1.4.2 and it falls back to System.currentTimeMillis
* on earlier JDKs.
*
* @author Dawid Kurzyniec
* @version 1.0
*/
public final class Utils {
private final static NanoTimer nanoTimer;
private final static String providerProp =
"edu.emory.mathcs.backport.java.util.concurrent.NanoTimerProvider";
static {
NanoTimer timer = null;
try {
String nanoTimerClassName =
AccessController.doPrivileged(new PrivilegedActionsun.misc.Perf
on Java 1.4.2, and falls back to
* System.currentTimeMillis() emulation on earlier JDKs. Custom
* timer can be provided via the system property
* edu.emory.mathcs.backport.java.util.concurrent.NanoTimerProvider
.
* The value of the property should name a class implementing
* {@link NanoTimer} interface.
* sun.misc.Perf
timer seems to have
* resolution of the order of 1 microsecond, measured on Linux.
*
* @return The current value of the system timer, in nanoseconds.
*/
public static long nanoTime() {
return nanoTimer.nanoTime();
}
/**
* Causes the current thread to wait until it is signalled or interrupted,
* or the specified waiting time elapses. This method originally appears
* in the {@link Condition} interface, but it was moved to here since it
* can only be emulated, with very little accuracy guarantees: the
* efficient implementation requires accurate nanosecond timer and native
* support for nanosecond-precision wait queues, which are not usually
* present in JVMs prior to 1.5. Loss of precision may cause total waiting
* times to be systematically shorter than specified when re-waits occur.
*
*
*
*
*
*
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared. It is not specified, in the first
* case, whether or not the test for interruption occurs before the lock
* is released.
*
*
* synchronized boolean aMethod(long timeout, TimeUnit unit) {
* long nanosTimeout = unit.toNanos(timeout);
* while (!conditionBeingWaitedFor) {
* if (nanosTimeout > 0)
* nanosTimeout = theCondition.awaitNanos(nanosTimeout);
* else
* return false;
* }
* // ...
* }
*
*
*