深入学习锁--Lock各种使用方法

一、什么是Lock

Lock是一个接口,通常所说的可重入锁是指Lock的一个实现子类ReentrantLock

二、Lock实现步骤：

①创建锁对象Lock lock = new ReentrantLock();

②加锁lock.lock();

③释放锁lock.unlock();

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * 手动锁（可重入锁的基本使用）
 */
public class ThreadLock {
    public static void main(String[] args) {
        //1.创建锁对象
        Lock lock = new ReentrantLock();
        //2.加锁操作
        lock.lock();
        try{
            //业务代码（可能会非常复杂->可能会导致异常，后面的代码就不执行了，锁就无法释放，当前线程会永久占用锁资源）
            //所以要用try-catch-finally（可以没有catch）
            System.out.println("你好，ReentrantLock.");
        } finally {
            //3.释放锁（一定要放在finally中）
            lock.unlock(); 
        }
    }
}

--->注意事项：

1.unlock()一定要放在finally里，否则可能导致锁资源永久占用问题。

2.lock()要放到try外（官方建议）或try中的首行（问题不大）。

lock.lock();  
try {
    
} finally {
    lock.unlock()
}

try {
    lock.lock(); 
    int n = 1/0; 
} finally {
    lock.unlock()
}

--->这种不行

try {
    int n = 1/0;
    lock.lock();  
} finally {
    lock.unlock()
}

原因有两个：

如果放在 try ⾥⾯，因为 try 代码中的异常导致加锁失败，但还会执行 finally 释放锁的操作。未加锁却释放锁，肯定会报错。
报错信息中：unlock 异常会覆盖 try ⾥⾯的业务异常，从而增加调式程序和修复程序的复杂度，增加排查错误的难度。

三、Lock指定锁类型——公平锁和非公平锁

//1.创建锁对象
Lock lock = new ReentrantLock(true); //公平锁
Lock lock = new ReentrantLock(); //非公平锁
Lock lock = new ReentrantLock(false); //非公平锁

使用公平锁比使用非公平锁要慢！

四、（面试必问）

4.1synchronized VS Lock（ReentrantLock）

实现方式：Synchronized是Java语言内置的关键字，而Lock是一个Java接口。
锁的获取和释放：Synchronized是隐式获取和释放锁，由Java虚拟机自动完成；而Lock需要显式地调用lock()方法获取锁，并且必须在finally块中调用unlock()方法来释放锁。
可中断性：在获取锁的过程中，如果线程被中断，synchronized会抛出InterruptedException异常并且自动释放锁，而Lock则需要手动捕获InterruptedException异常并处理，同时也支持非阻塞、可轮询以及定时获取锁的方式。
公平性：Synchronized不保证线程获取锁的公平性，而Lock可以通过构造函数指定公平或非公平锁。
锁状态：Synchronized无法判断锁的状态，而Lock可以通过tryLock()、isLocked()来判断锁的状态(线程是否可能取到锁、锁是否被占用等)。
粒度：Synchronized锁的粒度较粗，只能锁住整个方法或代码块，而Lock可以细粒度地控制锁的范围，比如锁某个对象的部分属性。
场景：如果在简单的并发场景下，推荐使用Synchronized；而在需要更高级的锁控制时，可以考虑使用Lock。

一般情况建议使用Synchronized,在JDK1.5之前Lock优于Synchronized，但在JDK1.5之后对Synchronized进行了优化，后面在性能方面基本与Lock一样且使用简单(有作者说"Synchronized是亲生的，JDK还是会一直优化他不会让Lock优于它")。

4.2 Synchronized原理

Synchronized是Java语言中最常用的同步机制之一，它可以确保多个线程访问共享资源时的互斥性和可见性。Synchronized关键字的原理如下：

Synchronized使用了内置锁（也称为监视器锁）来实现同步。每个Java对象都有一个内置锁，当该对象作为锁被获取时，其他试图获取该锁的线程会被阻塞，直到该锁被释放。
Synchronized的锁是与对象相关联的。当一个线程进入Synchronized代码块时，它必须先获取该对象的锁才能执行代码，否则就会被阻塞。当该线程退出Synchronized代码块时，它会自动释放该对象的锁。
Synchronized具有可重入性。如果当前线程已经获得了某个对象的锁，那么它可以继续访问该对象的其他Synchronized代码块，而不会被自己持有的锁所阻塞。
Synchronized还具有volatile变量的读写语义。在使用Synchronized关键字时，内存屏障会确保本地线程中修改过的变量值被刷新回主内存，从而保证了多个线程之间对变量修改的可见性。

Synchronized通过使用内置锁、与对象关联的锁、可重入性以及内存屏障等机制来实现线程的同步和锁的管理，以保证对共享资源的访问具有互斥性和可见性。

4.3 Lock原理

Lock是Java语言中的一种高级同步机制，它提供了比Synchronized更加灵活和可扩展的同步特性。Lock机制的原理如下：

Lock使用了对象的锁来实现同步。每个Lock对象都有一个锁，当该锁被获取时，其他试图获取该锁的线程会被阻塞，直到该锁被释放。
Lock的锁是与对象无关的。相比于Synchronized关键字，Lock提供了更加灵活的方式来控制锁的获取和释放。例如，它支持可中断的获取锁操作、超时获取锁操作等等。因此，在需要手动控制锁的获取和释放时，Lock是一个很好的选择。
Lock还具有可重入性。如果当前线程已经获得了某个Lock对象的锁，那么它可以继续访问该对象的其他Lock代码块，而不会被自己持有的锁所阻塞。
Lock使用了条件变量来实现线程的等待和通知。Condition接口提供了await()、signal()和signalAll()等方法，用于线程之间的等待和通知，从而避免了Object类中wait()和notify()方法可能出现的信号丢失问题。

Lock通过使用对象的锁、与对象无关的锁、可重入性以及条件变量等机制来实现线程的同步和锁的管理，以保证对共享资源的访问具有互斥性和可见性。与Synchronized关键字相比，Lock提供了更加灵活和可扩展的同步特性，但也需要更多的代码来控制锁的获取和释放。

4.4、Synchronized与Lock使用

Synchronized

public class Counter {
        private int count;

        public synchronized void increment() {
            count++;
        }
    }

Lock

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

public class Counter {
    private int count;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

上述代码也是定义了一个计数器类Counter，但是使用的是Lock接口来实现线程同步。在这种情况下，需要先创建一个ReentrantLock对象，然后在需要同步的代码块中调用lock()方法获取锁，在finally块中调用unlock()方法释放锁。

总的来说，Synchronized更加简单易用，适合用于一些简单的并发场景；而Lock提供了更多的灵活性和可扩展性，适合用于一些复杂的并发场景。