Java TimeUnit.timedWait方法代码示例

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
@Override
public T get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
  synchronized (tasks) {
    if (resultObtained) {
      return result;
    }
    if (exeEx != null) {
      throw exeEx;
    }
    unit.timedWait(tasks, timeout);
  }
  if (resultObtained) {
    return result;
  }
  if (exeEx != null) {
    throw exeEx;
  }

  throw new TimeoutException("timeout=" + timeout + ", " + unit);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
/**
 * Waits for a Locator status request response to be returned up to the specified timeout in the
 * given unit of time. This call will send status requests at fixed intervals in the given unit of
 * time until the timeout expires. If the request to determine the Locator's status is successful,
 * then the Locator is considered to be 'ONLINE'. Otherwise, the Locator is considered to be
 * unresponsive to the status request.
 * 
 * However, this does not necessarily imply the Locator start was unsuccessful, only that a
 * response was not received in the given time period.
 * 
 * Note, this method does not block or cause the Locator's location-based services (daemon
 * Threads) to continue running in anyway if the main application Thread terminates when running
 * the Locator in-process. If the caller wishes to start a Locator in an asynchronous manner
 * within the application process, then a call should be made to <code>waitOnLocator</code>.
 * 
 * @param timeout a long value in time unit indicating when the period of time should expire in
 *        attempting to determine the Locator's status.
 * @param interval a long value in time unit for how frequent the requests should be sent to the
 *        Locator.
 * @param timeUnit the unit of time in which the timeout and interval are measured.
 * @return the state of the Locator, which will either be 'ONLINE' or "NOT RESPONDING'. If the
 *         status returned is 'NOT RESPONDING', it just means the Locator did not respond to the
 *         status request within the given time period. It should not be taken as the Locator
 *         failed to start.
 * @see #waitOnLocator()
 */
public LocatorState waitOnStatusResponse(final long timeout, final long interval,
    final TimeUnit timeUnit) {
  final long endTimeInMilliseconds = (System.currentTimeMillis() + timeUnit.toMillis(timeout));

  while (System.currentTimeMillis() < endTimeInMilliseconds) {
    try {
      LocatorStatusResponse response = statusLocator(getPort(), getBindAddress());
      return new LocatorState(this, Status.ONLINE, response);
    } catch (Exception ignore) {
      try {
        synchronized (this) {
          timeUnit.timedWait(this, interval);
        }
      } catch (InterruptedException ignoreInterrupt) {
        // NOTE just go and send another status request to the Locator...
      }
    }
  }

  // NOTE just because we were not able to communicate with the Locator in the given amount of
  // time does not mean
  // the Locator is having problems. The Locator could be slow in starting up and the timeout may
  // not be
  // long enough.
  return new LocatorState(this, Status.NOT_RESPONDING);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
@Override
public CommandResult get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
    synchronized (this) {
        if (result != null) {
            return result;
        }
        unit.timedWait(this, timeout);
        if (result == null) {
            set(new CommandResult());
            networkManager.removeCommandExecution(commandExecution);
        }
        return result;
    }
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
public QueueingFuture<V> poll(long timeout, TimeUnit unit) throws InterruptedException {
  synchronized (tasks) {
    if (completed == null && !cancelled) unit.timedWait(tasks, timeout);
  }
  return completed;
}