Java并发编程札记-(四)JUC锁-02Lock与ReentrantLock

2023年5月29日 231次阅读 来源: java并发

今天学习Lock与ReentrantLock。

Java中的锁有两种，synchronized与Lock。因为使用synchronized并不需要显示地加锁与解锁，所以往往称synchronized为隐式锁，而使用Lock时则相反，所以一般称Lock为显示锁。想了解synchronized更多请移步Java并发编程札记-(一)基础-06synchronized详解。

synchronized修饰方法或语句块，所有锁的获取和释放都必须出现在一个块结构中。当需要灵活地获取或释放锁时，synchronized显然是不符合要求的。Lock接口的实现允许锁在不同的范围内获取和释放，并支持以任何顺序获取和释放多个锁。

一句话，Lock实现比synchronized更灵活。但凡事有利就有弊，不使用块结构锁就失去了使用synchronized修饰方法或语句时会出现的锁自动释放功能，在大多数情况下，Lock实现需要手动释放锁。

除了更灵活之外，Lock还有以下优点：

  • Lock 实现提供了使用 synchronized 方法和语句所没有的其他功能，包括提供了一个非块结构的获取锁尝试 (tryLock())、一个获取可中断锁的尝试 (lockInterruptibly()) 和一个获取超时失效锁的尝试 (tryLock(long, TimeUnit))。
  • Lock 类还可以提供与隐式监视器锁完全不同的行为和语义，如保证排序、非重入用法或死锁检测。如果某个实现提供了这样特殊的语义，则该实现必须对这些语义加以记录。

ReentrantLock是一个可重入的互斥锁。顾名思义，“互斥锁”表示在某一时间点只能被同一线程所拥有。“可重入”表示锁可被某一线程多次获取。

当锁没有被某一线程占有时，调用lock()方法的线程将成功获取锁。可以使用isHeldByCurrentThread()和 getHoldCount()方法来判断当前线程是否拥有该锁。

ReentrantLock既可以是公平锁又可以是非公平锁。当此类的构造方法ReentrantLock(boolean fair) 接收true作为参数时，ReentrantLock就是公平锁，线程依次排队获取公平锁，即锁将被等待最长时间的线程占有。与默认情况（使用非公平锁）相比，使用公平锁的程序在多线程环境下效率比较低。而且公平锁不能保证线程调度的公平性，tryLock方法可在锁未被其他线程占用的情况下获得该锁。

方法列表

//构造方法摘要
ReentrantLock() 
          //创建一个 ReentrantLock 的实例。
ReentrantLock(boolean fair) 
          //创建一个具有给定公平策略的 ReentrantLock。 
//方法摘要
int getHoldCount() 
          //查询当前线程保持此锁的次数。
protected  Thread   getOwner() 
          //返回目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回 null。
protected  Collection<Thread>   getQueuedThreads() 
          //返回一个 collection，它包含可能正等待获取此锁的线程。
 int    getQueueLength() 
          //返回正等待获取此锁的线程估计数。
protected  Collection<Thread>   getWaitingThreads(Condition condition) 
          //返回一个 collection，它包含可能正在等待与此锁相关给定条件的那些线程。
 int    getWaitQueueLength(Condition condition) 
          //返回等待与此锁相关的给定条件的线程估计数。
 boolean    hasQueuedThread(Thread thread) 
          //查询给定线程是否正在等待获取此锁。
 boolean    hasQueuedThreads() 
          //查询是否有些线程正在等待获取此锁。
 boolean    hasWaiters(Condition condition) 
          //查询是否有些线程正在等待与此锁有关的给定条件。
 boolean    isFair() 
          //如果此锁的公平设置为 true，则返回 true。
 boolean    isHeldByCurrentThread() 
          //查询当前线程是否保持此锁。
 boolean    isLocked() 
          //查询此锁是否由任意线程保持。
 void   lock() 
          //获取锁。
 void   lockInterruptibly() 
          //如果当前线程未被中断，则获取锁。
 Condition  newCondition() 
          //返回用来与此 Lock 实例一起使用的 Condition 实例。
 String toString() 
          //返回标识此锁及其锁定状态的字符串。
 boolean    tryLock() 
          //仅在调用时锁未被另一个线程保持的情况下，才获取该锁。
 boolean    tryLock(long timeout, TimeUnit unit) 
          //如果锁在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁。
 void   unlock() 
          //试图释放此锁。

使用最典型的代码如下

class X {
    private final ReentrantLock lock = new ReentrantLock();
    // ...

    public void m() { 
        lock.lock();  // block until condition holds
        try {
            // ... method body
        } finally {
            lock.unlock()
        }
    }
}

修改下Java并发编程札记-(一)基础-06synchronized详解中火车票订票系统实例，使用ReentrantLock实现线程安全。
例6：火车票订票系统-ReentrantLock实现线程安全版

import java.util.concurrent.locks.ReentrantLock;

public class SellTickets {

    public static void main(String[] args) {
        TicketsWindow tw1 = new TicketsWindow();
        Thread t1 = new Thread(tw1, "一号窗口");
        Thread t2 = new Thread(tw1, "二号窗口");
        t1.start();
        t2.start();
    }
}

class TicketsWindow implements Runnable {
    private int tickets = 1;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + "还剩余票:" + tickets + "张");
                    --tickets;
                    System.out.println(Thread.currentThread().getName() + "卖出一张火车票,还剩" + tickets + "张");
                } else {
                    System.out.println(Thread.currentThread().getName() + "余票不足,暂停出售!");
                    try {
                        Thread.sleep(1000 * 60);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

在某些方法的参数中出现了Condition，在后面我们会详细介绍Condition。

总结

  • 与synchronized 相比ReentrantLock的使用更灵活。Lock接口的实现允许锁在不同的范围内获取和释放，并支持以任何顺序获取和释放多个锁。
  • ReentrantLock具有与使用 synchronized 相同的一些基本行为和语义，但功能更强大。包括提供了一个非块结构的获取锁尝试 (tryLock())、一个获取可中断锁的尝试 (lockInterruptibly()) 和一个获取超时失效锁的尝试 (tryLock(long, TimeUnit))。
  • ReentrantLock具有synchronized所没有的许多特性，比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者轮询锁。
  • ReentrantLock可伸缩性强，应当在高度争用的情况下使用它。

本文就讲到这里，想了解Java并发编程更多内容请参考：

  • Java并发编程札记-目录

参考：

  • JDK 5.0 中更灵活、更具可伸缩性的锁定机制

END.

    原文作者：java并发
    原文地址: http://blog.csdn.net/panweiwei1994/article/details/78752639
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞