View Javadoc

    1   /*
    2    * Copyright 2012 The Netty Project
    3    *
    4    * The Netty Project licenses this file to you under the Apache License,
    5    * version 2.0 (the "License"); you may not use this file except in compliance
    6    * with the License. You may obtain a copy of the License at:
    7    *
    8    *   http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
    13   * License for the specific language governing permissions and limitations
    14   * under the License.
    15   */
    16  package org.jboss.netty.util.internal;
    17
    18  import java.util.concurrent.TimeUnit;
    19  import java.util.concurrent.locks.AbstractQueuedSynchronizer;
    20  import java.util.concurrent.locks.Condition;
    21  import java.util.concurrent.locks.Lock;
    22
    23  public final class NonReentrantLock extends AbstractQueuedSynchronizer
    24                               implements Lock {
    25
    26      private static final long serialVersionUID = -833780837233068610L;
    27
    28      private Thread owner;
    29
    30      public void lock() {
    31          acquire(1);
    32      }
    33
    34      public void lockInterruptibly() throws InterruptedException {
    35          acquireInterruptibly(1);
    36      }
    37
    38      public boolean tryLock() {
    39          return tryAcquire(1);
    40      }
    41
    42      public boolean tryLock(long time, TimeUnit unit)
    43              throws InterruptedException {
    44          return tryAcquireNanos(1, unit.toNanos(time));
    45      }
    46
    47      public void unlock() {
    48          release(1);
    49      }
    50
    51      public boolean isHeldByCurrentThread() {
    52          return isHeldExclusively();
    53      }
    54
    55      public Condition newCondition() {
    56          return new ConditionObject();
    57      }
    58
    59      @Override
    60      protected boolean tryAcquire(int acquires) {
    61          if (compareAndSetState(0, 1)) {
    62              owner = Thread.currentThread();
    63              return true;
    64          }
    65          return false;
    66      }
    67
    68      @Override
    69      protected boolean tryRelease(int releases) {
    70          if (Thread.currentThread() != owner) {
    71              throw new IllegalMonitorStateException();
    72          }
    73          owner = null;
    74          setState(0);
    75          return true;
    76      }
    77
    78      @Override
    79      protected boolean isHeldExclusively() {
    80          return getState() != 0 && owner == Thread.currentThread();
    81      }
    82  }