Java Lock示例 - ReentrantLock

2019年4月26日 149次阅读 来源: 后端开发

引言

在多线程环境下，通常我们使用 synchronized 关键字来保证线程安全。

大多数情况下，用 synchronized 关键字就足够了，但它也有一些缺点, 所以在 Java Concurrency 包中引入了 Lock API 。从Java 1.5版开始在 java.util.concurrent.locks 包中提供了处理并发的 Concurrency API 的 Lock 锁接口和一些实现类来改进 Object 锁定机制。

Java Lock API中的一些重要接口和类

Java Lock API中的一些重要接口和类是：

  • 锁(Lock)：这是Lock API的基本接口。它提供了 synchronized 关键字的所有功能，以及为锁定创建不同条件的其他方法，为线程等待锁定提供超时功能。一些重要的方法是 lock() 获取锁，unlock() 释放锁，tryLock() 等待锁定一段时间，newCondition() 创建条件等。
  • 条件(Condition)：条件对象类似于对象等待通知( Object wait-notify)模型，具有创建不同等待集的附加功能。Condition 对象始终由 Lock 对象创建。一些重要的方法是 await()，类似于Object.wait() 和 signal()，signalAll()，类似于 Object.notify() 和 Object.notifyAll() 方法。
  • 读写锁(ReadWriteLock)：它包含一对关联的锁，一个用于只读操作，另一个用于写入。只要没有写入线程，读锁可以由多个读取线程同时保持。写锁是独占的。
  • 重入锁(ReentrantLock)：这是最广泛使用的 Lock 接口实现类。此类以与 synchronized 关键字类似的方式实现 Lock 接口。除了 Lock 接口实现之外，ReentrantLock 还包含一些实用程序方法来获取持有锁的线程，等待获取锁线程等。

synchronized 块

synchronized 块本质上是可重入的，即如果一个线程锁定了监视对象，并且另一个同步块需要锁定在同一个监视对象上，则线程可以进入该代码块。我认为这就是类名是ReentrantLock的原因。让我们通过一个简单的例子来理解这个特性。

public class Test{

public synchronized foo(){
    //do something
    bar();
  }

  public synchronized bar(){
    //do some more
  }
}

如果一个线程进入 foo()，它就会锁定Test对象，所以当它尝试执行 bar() 方法时，允许该线程执行 bar() 方法，因为它已经在 Test 对象上持有锁，即与 synchronized(this) 效果是一样的。

Java Lock 示例 – Java 中的 ReentrantLock

现在让我们看一个简单的例子，我们将使用 Java Lock API 替换 synchronized 关键字。

假设我们有一个 Resource 类，其中包含一些操作，我们希望它是线程安全的，以及一些不需要线程安全的方法。

package com.journaldev.threads.lock;

public class Resource {

    public void doSomething(){
        //do some operation, DB read, write etc
    }
    
    public void doLogging(){
        //logging, no need for thread safety
    }
}

现在假设我们有一个 Runnable 类，我们将使用 Resource 方法。

package com.journaldev.threads.lock;

public class SynchronizedLockExample implements Runnable{

    private Resource resource;
    
    public SynchronizedLockExample(Resource r){
        this.resource = r;
    }
    
    @Override
    public void run() {
        synchronized (resource) {
            resource.doSomething();
        }
        resource.doLogging();
    }
}

请注意，我使用 synchronized 块来获取 Resource 对象上的锁。我们可以在类中创建一个虚拟对象，并将其用于锁定的目的。

现在让我们看看我们如何使用 Java Lock API 并重写上面的程序而不使用 synchronized 关键字。我们将在Java 中使用 ReentrantLock。

package com.journaldev.threads.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConcurrencyLockExample implements Runnable{

    private Resource resource;
    private Lock lock;
    
    public ConcurrencyLockExample(Resource r){
        this.resource = r;
        this.lock = new ReentrantLock();
    }
    
    @Override
    public void run() {
        try {
            if(lock.tryLock(10, TimeUnit.SECONDS)){
               resource.doSomething();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            //release lock
            lock.unlock();
        }
        resource.doLogging();
    }

}

正如你所看到的，我正在使用 tryLock() 方法来确保我的线程只等待一定的时间，如果它没有获得对象的锁定，它只是记录和退出。另一个要注意的重点是使用 try-finally 块来确保即使 doSomething() 方法调用抛出任何异常也会释放锁定。

Java Lock 与 synchronized 比较

基于以上细节和程序，我们可以很容易地得出 Java Lock 和同步之间的以下差异。

  • Java Lock API 为锁定提供了更多的可见性和选项，不像在线程可能最终无限期地等待锁定的同步，我们可以使用tryLock() 来确保线程仅等待特定时间。
  • 用同步关键字的代码更清晰，更易于维护，而使用 Lock，我们不得不尝试使用 try-finally 块来确保即使在 lock() 和 unlock() 方法调用之间抛出异常也会释放 Lock。
  • 同步块或方法只能覆盖一种方法，而我们可以在一种方法中获取锁，并使用 Lock API 在另一种方法中释放它。
  • synchronized 关键字不提供公平性，而我们可以在创建 ReentrantLock 对象时将公平性设置为 true，以便最长等待的线程首先获得锁定。
  • 我们可以为 Lock 创建不同的等待条件(Condition)，不同的线程可以针对不同的条件来 await() 。

这就是 Java Lock 示例，Java 中的 ReentrantLock 以及使用 synchronized 关键字的比较分析。

作 者:

关于Pankaj
《Java Lock示例 - ReentrantLock》
如果你走得这么远，那就意味着你喜欢你正在读的东西。为什么不直接在Google Plus，Facebook或Twitter上与我联系。我很想直接听到你对我的文章的想法和意见。

最近我开始创建视频教程，所以请在Youtube上查看我的视频。

    原文作者：后端开发
    原文地址: https://segmentfault.com/a/1190000017573192
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞