【深入分析Java多线程】（7）Lock

男娘i 2022-07-14 13:37 133阅读 0赞

提到java中的锁，相信大家都知道它是用来控制多个线程访问共享资源的方式(即锁能防止多个线程同时访问空享资源而出现线程安全问题)。在实践过程中使用最多的也最常见的锁就是 synchronized 在jdk1.5之前也仅仅有这一种锁而已。在jdk1.5之后，并发包中新增了Lock接口(以及相关实现类)用来实现锁功能，Lock接口提供了与synchronized关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。虽然Lock接口没有synchronized关键字自动获取和释放锁那么便捷，但Lock接口却具有了锁的可操作性，可中断获取以及超时获取锁等多种非常实用的同步特性，除此之外Lock接口还有两个非常强大的实现类重入锁和读写锁，下面一一讲解这些内容。Lock接口的使用

Lock lock  = new ReentrantLock();
    lock.lock();
    try{
    //可能会出现线程安全的操作
    }finally{
    //一定在finally中释放锁
    //也不能把获取锁在try中进行，因为有可能在获取锁的时候抛出异常
      lock.ublock();
    }

*  > ## 欢迎关注公众号： ##
    > 
    > # ![70][] #

Lock接口与synchronized关键字的区别

>  *  Lock接口可以尝试非阻塞地获取锁 当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。   
>     \*Lock接口能被中断地获取锁 与synchronized不同，获取到锁的线程能够响应中断，当获取到的锁的线程被中断时，中断异常将会被抛出，同时锁会被释放。
>  *  Lock接口在指定的截止时间之前获取锁，如果截止时间到了依旧无法获取锁，则返回。

Lock接口的API

>  *  void lock() 获取锁,调用该方法当前线程将会获取锁，当锁获取后，该方法将返回。
>  *  void lockInterruptibly() throws InterruptedException 可中断获取锁，与lock()方法不同之处在于该方法会响应中断，即在锁的获取过程中可以中断当前线程
>  *  boolean tryLock() 尝试非阻塞的获取锁，调用该方法立即返回，true表示获取到锁
>  *  boolean tryLock(long time,TimeUnit unit) throws InterruptedException 超时获取锁，以下情况会返回：时间内获取到了锁，时间内被中断，时间到了没有获取到锁。
>  *  void unlock() 释放锁

了解Lock接口最常用的实现ReentrantLock重入锁

ReentrantLock是Lock接口一种常见的实现，它是支持重进入的锁即表示该锁能够支持一个线程对资源的重复加锁。该锁还支持获取锁时的公平与非公平的选择。   
关于锁的重进入，其实synchronized关键字也支持。如前所述，synchronized关键字也是隐式的支持重进入而对于ReentrantLock而言，对于已经获取到锁的线程，再次调用lock()方法时依然可以获取锁而不被阻塞。   
理解了锁的重进入，现在解释刚刚提到的公平获取锁与非公平获取锁。如果在绝对时间上，先对于锁进行获取的请求一定先被满足，那么这个锁就是公平的，反之就是非公平的。公平的获取锁也就是等待时间最久的线程优先获取到锁。ReentrantLock的构造函数来控制是否为公平锁。

我在第一次了解到公平锁于非公平锁的时候，第一反应是公平锁的效率高，应该使用公平锁。但实际的情况是，非公平的锁的效率远远大于公平锁。

了解Lock接口的实现类ReentrantReadWriteLock读写锁

前面提到的ReentrantLock是排他锁，该锁在同一时刻只允许一个线程来访问，而读写锁在同一时刻允许可以有多个线程来访问，但在写线程访问时，所有的读线程和其他写线程被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过读写锁分离，使得并发性相比一般的排他锁有了很大的提升。

读写锁除了使用在写操作happends-before与读操作以及并发性的提升之外，读写锁也能够简化读写交互场景的编程方式。假设在程序中定义一个共享的用作缓存数据结构，它的大部分时间提供读服务(查询，搜索等)而写操作较少，但写操作之后需要立即对后续的读操作可见。在没有读写锁之前，实现这个功能需要使用等待通知机制([http://blog.csdn.net/canot/article/details/50879963][http_blog.csdn.net_canot_article_details_50879963])。无论使用那种方式，目的都是为了写操作立即可见于读操作而避免脏读。但使用读写锁却比等待通知简单明了多了。   
一般情况下，读写锁性能优于排他锁。它能提供更好的并发性和吞吐量。

ReentrantReadWriteLock读写锁的几个特性:

>  *  公平选择性
>  *  重进入
>  *  锁降级

读写锁的示例:缓存

public class Cache{
      static Map<String,Object> map = new HashMap<String,Object>();
      static ReentrantReadWriteLock  rwl = new ReentrantReadWriteLock();
      static Lock rLock = rwl.readLock();
      static Lock wLock = rwl.writeLock();
      //获取一个key对应的value
      public static final Object get(String key){
      r.lock();
      try{
       return map.get(key);
       }finally{
        r.unlock();
        }
      }
      //设置key对应的value并返回旧的value
      public static fianl Object put(String key,Object value){
      w.lock();
      try{
       return map.put(key,value);
       }final{
       w.unlock();
        }
      }
      //清空缓存
      public static fianl void clear(){
      w.lock();
      try{
         map.clear();
       } finally{
        w.unlock();
        }
      }
    }

上述缓存示例中，我们使用了一个非线程安全的HashMap作为缓存的时候然后使用读写锁来保证线程安全。Cache使用读写锁提升读操作的并发性，也保证每次写操作对读操作的及时可见性，同时简化了编程方式。

读写锁的锁降级

锁降级是指写锁降级成为读锁。如果当前线程持有写锁，然后将其释放再获取读锁的过程不能称为锁降级。锁降级指的在持有写锁的时候再获取读锁,获取到读锁后释放之前写锁的过程称为锁释放。

锁降级在某些情况下是非常必要的，主要是为了保证数据的可见性。如果当前线程不获取读锁而直接释放写锁，假设此时另外一个线程获取了写锁并修改了数据。那么当前线程无法感知该线程的数据更新。

# Synchronized和java.util.concurrent.locks.Lock的区别 #

总的来说，lock更加灵活。
    主要相同点：Lock能完成synchronized所实现的所有功能
    不同： 
    1.ReentrantLock功能性方面更全面，比如时间锁等候，可中断锁等候，锁投票等，因此更有扩展性。在多个条件变量和高度竞争锁的地方，用ReentrantLock更合适，ReentrantLock还提供了Condition，对线程的等待和唤醒等操作更加灵活，一个ReentrantLock可以有多个Condition实例，所以更有扩展性。 
    2.ReentrantLock必须在finally中释放锁，否则后果很严重，编码角度来说使用synchronized更加简单，不容易遗漏或者出错。 
    3.ReentrantLock 的性能比synchronized会好点。 
    4.ReentrantLock提供了可轮询的锁请求，他可以尝试的去取得锁，如果取得成功则继续处理，取得不成功，可以等下次运行的时候处理，所以不容易产生死锁，而synchronized则一旦进入锁请求要么成功，要么一直阻塞，所以更容易产生死锁。 
    
    转载：
    
    1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候
    
         线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，
    
         如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断
    
         如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情
    
        ReentrantLock获取锁定与三种方式： 
        a)  lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁
    
        b) tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；
    
        c) tryLock (long timeout, TimeUnit  unit)，   如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；
    
        d) lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断
    
    2、synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将 unLock()放到finally{} 中
    
    3、在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态

[70]: /images/20220714/7eb599d5fc544b68b4b665c78387cdbd.png
[http_blog.csdn.net_canot_article_details_50879963]: http://blog.csdn.net/canot/article/details/50879963