Lock 概述及其实现

原创已于 2025-09-05 13:49:09 修改 · 882 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#java #lock

于 2025-09-05 13:43:52 首次发布

MySQL 专栏收录该内容

11 篇文章

订阅专栏

VibeCoding·九月创作之星挑战赛 10w+人浏览 368人参与

1. 什么是 Lock

Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。

它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能。

Lock 与的 Synchronized 区别

Lock 不是 Java 语言内置的，而 synchronized 是 Java 语言的关键字，因此是内置特性。Lock 是一个类，通过这个类可以实现同步访问；
Lock 和 synchronized 有一点非常大的不同，采用 synchronized 不需要开发人员去手动释放锁，当 synchronized 方法或者 synchronized 代码块执行完之后，系统会自动让线程释放对锁的占用；而 Lock 则必须要开发人员去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

1.1 Lock 接口

public interface Lock {    

    //	阻塞地获取锁
    void lock();    
    
    void lockInterruptibly() throws InterruptedException;    

    //	尝试非阻塞地获取锁
    boolean tryLock();    
    
    // 超时地获取锁
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;    

    //	释放锁
    void unlock(); 
    
    Condition newCondition(); 
}

下面来逐个讲述 Lock 接口中每个方法的使用

1.2 lock

lock() 方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

采用 Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用 Lock 必须在 try{} catch{} 块中进行，并且 将释放锁的操作放在 finally 块中进行 ，以保证锁一定被被释放，防止死锁的发生。

通常使用 Lock 来进行同步的话，是以下面这种形式去使用的：

Lock lock = ...; 
//	上锁
lock.lock(); 
try{ 
   //	处理任务 
}catch(Exception ex){ 
     
}finally{ 
   lock.unlock();   //释放锁 
}

1.3 newCondition

关键字 synchronized 与 wait()/notify() 这两个方法一起使用可以实现 等待/通知 模式， Lock 锁的 newContition() 方法返回 Condition 对象，Condition 类也可以实现等待/通知模式。

用 notify() 通知时，JVM 会随机唤醒改对象上某个等待的线程，使用 Condition 类可以进行选择性通知， Condition 比较常用的两个方法：

await() 会使当前线程等待,同时会释放锁, 当其他线程调用 signal() 时, 线程会重新获得锁并继续执行。
signal() 用于唤醒该对象上一个等待的线程。

注意：在调用 Condition 的 await()/signal()方法前，也需要线程持有相关的 Lock 锁，调用 await() 后线程会释放这个锁，在 singal() 调用后会从当前 Condition 对象的等待队列中，唤醒一个线程，唤醒的线程尝试获得锁，一旦获得锁成功就继续执行。

2. ReentrantLock

ReentrantLock，意思是“可重入锁”，默认是非公平锁。

ReentrantLock 是实现了 Lock 接口的类，并且 ReentrantLock 提供了更多的方法。下面通过一些实例看具体看一下如何使用。

public class Test {    
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();    
    public static void main(String[] args) {        
        final Test test = new Test(); 
        
        new Thread(){            
            public void run() { 
                test.insert(Thread.currentThread()); 
            }; 
        }.start(); 
        
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread()); 
            }; 
        }.start(); 
    }   
    
    public void insert(Thread thread) { 
        Lock lock = new ReentrantLock();    
        //注意这个地方
        lock.lock();        
        try { 
            System.out.println(thread.getName()+"得到了锁");            
            for(int i=0;i<5;i++) {                
                arrayList.add(i); 
            } 
        } catch (Exception e) { 
            //。。。
        }finally { 
            System.out.println(thread.getName()+"释放了锁");            
            lock.unlock(); 
        } 
    } 
}

3. ReadWriteLock

ReadWriteLock 也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock { 
    /** 
● Returns the lock used for reading. 
     * 
● @return the lock used for reading. 
     */ 
    Lock readLock(); 
  
    /** 
● Returns the lock used for writing. 
     * 
● @return the lock used for writing. 
     */ 
    Lock writeLock(); 
}

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成 2 个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的实现了 ReadWriteLock 接口。

ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和 writeLock()用来获取读锁和写锁。

下面通过几个例子来看一下 ReentrantReadWriteLock 具体用法。

假如有多个线程要同时进行读操作的话，先看一下 synchronized 实现的效果：

public class Test {
    public static void main(String[] args) {
        final Test test = new Test();
        
        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();
        
        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();
    
    }
    
    public synchronized void get(Thread thread) {
        long start = System.currentTimeMillis();
        while(System.currentTimeMillis() - start <= 1) {
            System.out.println(thread.getName()+"正在进行读操作");
        }
        System.out.println(thread.getName()+"读操作完毕");
    }
}

上面的案例运行的结果是：两个线程串行执行。

而改成用读写锁的话：

public class Test { 
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); 
    
    public static void main(String[] args)  {
        final Test test = new Test(); 
    
        new Thread(){
            public void run() {
                test.get(Thread.currentThread()); 
            }; 
        }.start(); 
        
        new Thread(){
            public void run() {
                test.get(Thread.currentThread()); 
            }; 
        }.start(); 
    
    }   
    
    public void get(Thread thread) {
        //	读锁
        rwl.readLock().lock(); 
        try { 
            long start = System.currentTimeMillis(); 
            while(System.currentTimeMillis() - start <= 1) { 
                System.out.println(thread.getName()+"正在进行读操作"); 
            } 
            System.out.println(thread.getName()+"读操作完毕"); 
        } finally {
            rwl.readLock().unlock(); 
        } 
    } 
}

上面的两个线程呈现出 **交替 **执行的场面。

说明 thread1 和 thread2 在同时进行读操作。这样就大大提升了读操作的效率。

注意: 读锁和写锁之间是互斥的奥~ 读锁与读锁不互斥。

如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

4. 小结(重点)

Lock 和 synchronized 都是可重入锁，有以下几点不同：

Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言实现；
synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁；
Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用 synchronized 时，等待的线程会一直等待下去，不能够响应中断；
通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。
Lock 可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时 Lock 的性能要优于 synchronized。