极客时间《Java并发编程实战》笔记--- Lock和Condition：隐藏在并发包中的管程

素颜马尾好姑娘i 2023-01-05 05:18 113阅读 0赞

### 文章目录 ###

*  Lock 与 synchronized 的区别
 *  如何保证可见性
 *  可重入锁---线程可以重复获取同一把锁。
 *  公平锁与非公平锁
 *  Lock&Condition 实现的管程与内置管程的区别
 *  同步与异步

# Lock 与 synchronized 的区别 #

**synchronized 得不到资源就一直想要！而且还不释放已经占用的资源**。而我们想要的结果是占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源，这样不可抢占这个条件就破坏掉了，能够有效避免死锁。所以就有了Lock的出现。如果实现起来，主要有三种方案可选择：

1.  **能够响应中断**。synchronized 的问题是，持有锁 A 后，如果尝试获取锁 B 失败，那么线程就进入阻塞状态，一旦发生死锁，就没有任何机会来唤醒阻塞的线程。但如果阻塞状态的线程能够响应中断信号，也就是说当我们给阻塞的线程发送中断信号的时候，能够唤醒它，那它就有机会释放曾经持有的锁 A。这样就破坏了不可抢占条件了。
2.  **支持超时**。如果线程在一段时间之内没有获取到锁，不是进入阻塞状态，而是返回一个错误，那这个线程也有机会释放曾经持有的锁。这样也能破坏不可抢占条件。
3.  **非阻塞地获取锁**。如果尝试获取锁失败，并不进入阻塞状态，而是直接返回，那这个线程也有机会释放曾经持有的锁。这样也能破坏不可抢占条件。

分别对应于 lock 中的三个接口：

// 支持中断的API
    void lockInterruptibly() 
      throws InterruptedException;
    // 支持超时的API
    boolean tryLock(long time, TimeUnit unit) 
      throws InterruptedException;
    // 支持非阻塞获取锁的API
    boolean tryLock();

# 如何保证可见性 #

> **可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到**  
> **原子性：把一个或者多个操作在 CPU 执行的过程中不被中断的特性**  
> **有序性：指的是程序按照代码的先后顺序执行**

Java SDK 里面 Lock 靠什么保证可见性呢？例如在下面的代码中，线程 T1 对 value 进行了 +=1 操作，那后续的线程 T2 能够看到 value 的正确结果吗？

class X { 
      private final Lock rtl =
      new ReentrantLock();
      int value;
      public void addOne() { 
        // 获取锁
        rtl.lock();  
        try { 
          value+=1;
        } finally { 
          // 保证锁能释放
          rtl.unlock();
        }
      }
    }

答：**是能够看到的**！原理就是 利用了 volatile 相关的 Happens-Before 规则。具体原理见即可时间上的描述吧。

# 可重入锁—线程可以重复获取同一把锁。 #

拿下面这块代码来举例，当线程 T1 执行到 ① 处时，已经获取到了锁 rtl ，当在 ① 处调用 get() 方法时，会在 ② 再次对锁 rtl 执行加锁操作。此时，如果锁 rtl 是可重入的，那么线程 T1 可以再次加锁成功；如果锁 rtl 是不可重入的，那么线程 T1 此时会被阻塞。

class X { 
      private final Lock rtl =
      new ReentrantLock();
      int value;
      public int get() { 
        // 获取锁
        rtl.lock();         ②
        try { 
          return value;
        } finally { 
          // 保证锁能释放
          rtl.unlock();
        }
      }
      public void addOne() { 
        // 获取锁
        rtl.lock();  
        try { 
          value = 1 + get(); ①
        } finally { 
          // 保证锁能释放
          rtl.unlock();
        }
      }
    }

# 公平锁与非公平锁 #

在等待队列中，公平锁就是谁等待的时间长，就唤醒谁，很公平；如果是非公平锁，则不提供这个保证，有可能等待时间短的线程反而先被唤醒。如：ReentrantLock 的两个构造函数所示：

//无参构造函数：默认非公平锁
    public ReentrantLock() { 
        sync = new NonfairSync();
    }
    //根据公平策略参数创建锁
    public ReentrantLock(boolean fair){ 
        sync = fair ? new FairSync() 
                    : new NonfairSync();
    }

# Lock&Condition 实现的管程与内置管程的区别 #

Java 语言内置的管程里只有一个条件变量，而 Lock&Condition 实现的管程是支持多个条件变量的，这是二者的一个重要区别。

# [同步与异步][Link 1] #

[Link 1]: https://blog.csdn.net/liushengxi_root/article/details/96499769