Java AtomicBoolean.wait方法代码示例

import java.util.concurrent.atomic.AtomicBoolean; //导入方法依赖的package包/类
/** @return true - if task should be interrupted; false - otherwise */
private boolean waitIfPaused() {
	AtomicBoolean pause = engine.getPause();
	synchronized (pause) {
		if (pause.get()) {
			log(LOG_WAITING_FOR_RESUME);
			try {
				pause.wait();
			} catch (InterruptedException e) {
				L.e(LOG_TASK_INTERRUPTED, memoryCacheKey);
				return true;
			}
			log(LOG_RESUME_AFTER_PAUSE);
		}
	}
	return checkTaskIsNotActual();
}
 

import java.util.concurrent.atomic.AtomicBoolean; //导入方法依赖的package包/类
public static boolean waitForConditionEx(final AtomicBoolean condition, long timeout)
throws InterruptedException
  {
      synchronized (condition) {
          long startTime = System.currentTimeMillis();
          while (!condition.get()) {
              condition.wait(timeout);
              if (System.currentTimeMillis() - startTime >= timeout ) {
                  break;
              }
          }
      }
      return condition.get();
  }
 

import java.util.concurrent.atomic.AtomicBoolean; //导入方法依赖的package包/类
static void waitFocused(Window w, AtomicBoolean b) {
    try {
        synchronized(b) {
            if (w.isFocusOwner()) {
                return;
            }
            b.wait(3000);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    if (!w.isFocusOwner()) {
        throw new RuntimeException("Can't make " + w + " focus owner");
    }
}
 

import java.util.concurrent.atomic.AtomicBoolean; //导入方法依赖的package包/类
/**
 * Update ZK or META.  This can take a while if for example the
 * hbase:meta is not available -- if server hosting hbase:meta crashed and we are
 * waiting on it to come back -- so run in a thread and keep updating znode
 * state meantime so master doesn't timeout our region-in-transition.
 * Caller must cleanup region if this fails.
 */
boolean updateMeta(final HRegion r, long masterSystemTime) {
  if (this.server.isStopped() || this.rsServices.isStopping()) {
    return false;
  }
  // Object we do wait/notify on.  Make it boolean.  If set, we're done.
  // Else, wait.
  final AtomicBoolean signaller = new AtomicBoolean(false);
  PostOpenDeployTasksThread t = new PostOpenDeployTasksThread(r,
    this.server, this.rsServices, signaller, masterSystemTime);
  t.start();
  // Post open deploy task:
  //   meta => update meta location in ZK
  //   other region => update meta
  // It could fail if ZK/meta is not available and
  // the update runs out of retries.
  long now = System.currentTimeMillis();
  long lastUpdate = now;
  boolean tickleOpening = true;
  while (!signaller.get() && t.isAlive() && !this.server.isStopped() &&
      !this.rsServices.isStopping() && isRegionStillOpening()) {
    long elapsed = now - lastUpdate;
    if (elapsed > 120000) { // 2 minutes, no need to tickleOpening too often
      // Only tickle OPENING if postOpenDeployTasks is taking some time.
      lastUpdate = now;
      if (useZKForAssignment) {
        tickleOpening = coordination.tickleOpening(
          ord, regionInfo, rsServices, "post_open_deploy");
      }
    }
    synchronized (signaller) {
      try {
        // Wait for 10 seconds, so that server shutdown
        // won't take too long if this thread happens to run.
        if (!signaller.get()) signaller.wait(10000);
      } catch (InterruptedException e) {
        // Go to the loop check.
      }
    }
    now = System.currentTimeMillis();
  }
  // Is thread still alive?  We may have left above loop because server is
  // stopping or we timed out the edit.  Is so, interrupt it.
  if (t.isAlive()) {
    if (!signaller.get()) {
      // Thread still running; interrupt
      LOG.debug("Interrupting thread " + t);
      t.interrupt();
    }
    try {
      t.join();
    } catch (InterruptedException ie) {
      LOG.warn("Interrupted joining " +
        r.getRegionInfo().getRegionNameAsString(), ie);
      Thread.currentThread().interrupt();
    }
  }

  // Was there an exception opening the region?  This should trigger on
  // InterruptedException too.  If so, we failed.  Even if tickle opening fails
  // then it is a failure.
  return ((!Thread.interrupted() && t.getException() == null) && tickleOpening);
}