Examples of java.util.concurrent.locks.ReentrantLock

java.util.concurrent.locks.ReentrantLock
public void m() { lock.lock(); // block until condition holds try { // ... method body } finally { lock.unlock() } } }}
In addition to implementing the {@link Lock} interface, thisclass defines a number of {@code public} and {@code protected}methods for inspecting the state of the lock. Some of these methods are only useful for instrumentation and monitoring.
Serialization of this class behaves in the same way as built-in locks: a deserialized lock is in the unlocked state, regardless of its state when serialized.
This lock supports a maximum of 2147483647 recursive locks by the same thread. Attempts to exceed this limit result in {@link Error} throws from locking methods. @since 1.5 @author Doug Lea

   */
  public void enterWhenUninterruptibly(Guard guard) {
    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    final ReentrantLock lock = this.lock;
    boolean reentrant = lock.isHeldByCurrentThread();
    lock.lock();
    try {
      waitUninterruptibly(guard, reentrant);
    } catch (Throwable throwable) {
      lock.unlock();
      throw Throwables.propagate(throwable);
    }
  }

View Full Code Here

   */
  public boolean enterWhen(Guard guard, long time, TimeUnit unit) throws InterruptedException {
    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    final ReentrantLock lock = this.lock;
    boolean reentrant = lock.isHeldByCurrentThread();
    long startNanos = System.nanoTime();
    if (!lock.tryLock(time, unit)) {
      return false;
    }
    boolean satisfied;
    try {
      long remainingNanos = unit.toNanos(time) - (System.nanoTime() - startNanos);
      satisfied = waitInterruptibly(guard, remainingNanos, reentrant);
    } catch (Throwable throwable) {
      lock.unlock();
      throw Throwables.propagate(throwable);
    }
    if (satisfied) {
      return true;
    } else {
      lock.unlock();
      return false;
    }
  }

View Full Code Here

   */
  public boolean enterWhenUninterruptibly(Guard guard, long time, TimeUnit unit) {
    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    final ReentrantLock lock = this.lock;
    boolean reentrant = lock.isHeldByCurrentThread();
    long startNanos = System.nanoTime();
    long timeoutNanos = unit.toNanos(time);
    long remainingNanos = timeoutNanos;
    boolean interruptIgnored = false;
    try {
      while (true) {
        try {
          if (lock.tryLock(remainingNanos, TimeUnit.NANOSECONDS)) {
            break;
          } else {
            return false;
          }
        } catch (InterruptedException ignored) {
          interruptIgnored = true;
        } finally {
          remainingNanos = (timeoutNanos - (System.nanoTime() - startNanos));
        }
      }
      boolean satisfied;
      try {
        satisfied = waitUninterruptibly(guard, remainingNanos, reentrant);
      } catch (Throwable throwable) {
        lock.unlock();
        throw Throwables.propagate(throwable);
      }
      if (satisfied) {
        return true;
      } else {
        lock.unlock();
        return false;
      }
    } finally {
      if (interruptIgnored) {
        Thread.currentThread().interrupt();

View Full Code Here

   */
  public boolean enterIf(Guard guard) {
    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    final ReentrantLock lock = this.lock;
    lock.lock();
    boolean satisfied;
    try {
      satisfied = guard.isSatisfied();
    } catch (Throwable throwable) {
      lock.unlock();
      throw Throwables.propagate(throwable);
    }
    if (satisfied) {
      return true;
    } else {
      lock.unlock();
      return false;
    }
  }

View Full Code Here

   */
  public boolean enterIfInterruptibly(Guard guard) throws InterruptedException {
    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    boolean satisfied;
    try {
      satisfied = guard.isSatisfied();
    } catch (Throwable throwable) {
      lock.unlock();
      throw Throwables.propagate(throwable);
    }
    if (satisfied) {
      return true;
    } else {
      lock.unlock();
      return false;
    }
  }

View Full Code Here

   */
  public boolean enterIf(Guard guard, long time, TimeUnit unit) {
    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    final ReentrantLock lock = this.lock;
    if (!enter(time, unit)) {
      return false;
    }
    boolean satisfied;
    try {
      satisfied = guard.isSatisfied();
    } catch (Throwable throwable) {
      lock.unlock();
      throw Throwables.propagate(throwable);
    }
    if (satisfied) {
      return true;
    } else {
      lock.unlock();
      return false;
    }
  }

View Full Code Here

  public boolean enterIfInterruptibly(Guard guard, long time, TimeUnit unit)
      throws InterruptedException {
    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    final ReentrantLock lock = this.lock;
    if (!lock.tryLock(time, unit)) {
      return false;
    }
    boolean satisfied;
    try {
      satisfied = guard.isSatisfied();
    } catch (Throwable throwable) {
      lock.unlock();
      throw Throwables.propagate(throwable);
    }
    if (satisfied) {
      return true;
    } else {
      lock.unlock();
      return false;
    }
  }

View Full Code Here

   */
  public boolean tryEnterIf(Guard guard) {
    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    final ReentrantLock lock = this.lock;
    if (!lock.tryLock()) {
      return false;
    }
    boolean satisfied;
    try {
      satisfied = guard.isSatisfied();
    } catch (Throwable throwable) {
      lock.unlock();
      throw Throwables.propagate(throwable);
    }
    if (satisfied) {
      return true;
    } else {
      lock.unlock();
      return false;
    }
  }

View Full Code Here

  /**
   * Leaves this monitor. May be called only by a thread currently occupying this monitor.
   */
  @GuardedBy("lock")
  public void leave() {
    final ReentrantLock lock = this.lock;
    if (!lock.isHeldByCurrentThread()) {
      throw new IllegalMonitorStateException();
    }
    try {
      signalConditionsOfSatisfiedGuards(null);
    } finally {
      lock.unlock();
    }
  }

View Full Code Here

   *
   * <p>This never needs to be called by a thread occupying the monitor, because all other monitor
   * methods ensure that all guards are evaluated whenever necessary.
   */
  public void reevaluateGuards() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
      signalConditionsOfSatisfiedGuards(null);
    } finally {
      lock.unlock();
    }
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.util.concurrent.locks.ReentrantLock

cc.redberry.pipe.blocks.Buffer

com.alibaba.druid.pool.DruidAbstractDataSource

com.alibaba.druid.pool.DruidDataSource

com.alibaba.otter.canal.store.memory.MemoryEventStoreWithBuffer

com.avaje.ebeaninternal.server.lib.sql.PooledConnectionQueue

com.facebook.presto.jdbc.internal.guava.util.concurrent.Monitor

com.google.common.util.concurrent.CycleDetectingLockFactoryBenchmark

com.google.common.util.concurrent.CycleDetectingLockFactoryTest

com.google.common.util.concurrent.Monitor

com.log4ic.DocViewer

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.