7

当我在http://javarevisited.blogspot.in/2013/03/reentrantlock-example-in-java-synchronized-difference-vs-lock.html运行示例类时，我看到的行为与synchronized.

4

3 回答 3

6

以下是线程访问锁和释放锁的三种方式和方法。您可能想尝试使用synchronized关键字来实现这些。使用的扩展能力和优势ReentrantLock将变得显而易见。

public class DoorLockUsingLock {

    private int counter= 0;
    private Thread owner= null;
    private Lock l = new ReentrantLock();
    private Condition notLocked= l.newCondition();

    public void lockItDown() throws InterruptedException {
        l.lockInterruptibly();
        try {
            while ((counter> 0) && (owner!= Thread.currentThread())) {
                notLocked.await();
            }
            counter++;
            owner = Thread.currentThread();
        } finally {
            l.unlock();
        }
    }

    public void lockItDownUninterruptibly() {
        l.lock();
        try {
            while ((counter > 0) && (owner != Thread.currentThread())) {
                notLocked.awaitUninterruptibly();
            }
            counter++;
            owner= Thread.currentThread();
        } finally {
            l.unlock();
        }
    }

    public boolean tryLockItDown(long timeout, TimeUnit unit) throws InterruptedException {
        long time = unit.toNanos(timeout);
        long end = System.nanoTime() + time;
        boolean success = l.tryLock(timeout, unit);
        if (!success) {
            return false;
        }
        try {
            time = end- System.nanoTime();
            while ((counter> 0) && (owner != Thread.currentThread()) && (time > 0)) {
                notLocked.await(time, TimeUnit.NANOSECONDS);
                time = end - System.nanoTime();
            }
            if (time > 0) {
                counter++;
                owner = Thread.currentThread();
                return true;
            }
            return false;
        } finally {
            l.unlock();
        }
    }

    public void unlockIt() throws IllegalMonitorStateException {
        l.lock();
        try {
            if (counter== 0) {
                throw new IllegalMonitorStateException();
            }
            if (owner!= Thread.currentThread()) {
                throw new IllegalMonitorStateException();
            }
            counter--;
            if (counter == 0) {
                owner = null;
                notLocked.signal();
            }
        } finally {
            l.unlock();
        }
    }
}
于 2013-08-28T18:47:32.327 回答
2

来自ReetrantLock 类的 JavaDoc：

Lock具有与使用方法和语句访问的隐式监视器锁相同的基本行为和语义的可重入互斥synchronized ，但具有扩展功能。

在您的示例中，您不使用“扩展功能”；您可以将ReentrantLock用作该方法的等效替代synchronized方法（除了该synchronized语句，您将this其用作锁）。所以这两种方法的行为必须相同。

于 2013-08-28T18:35:31.360 回答
0

不，您通常不会看到行为上的差异。但正如网站所说，有几种情况您需要使用 aReentrantLock而不是synchronized.

  1. 您希望公平选择等待线程。
  2. 您想使用 tryLock() 方法。
  3. 你想中断一个等待的线程并让它做其他事情。
  4. ReentrantLock 的性能比同步的要好，你关心它。

如果您不需要任何这些改进，使用synchronized就好了，您可能无法区分。

于 2013-08-28T18:35:12.340 回答