synchronized 与 Lock 接口的奥秘

• 1 同步的方式
• 1.1 synchronized关键字
• 1.2 显式锁（Lock接口）
• 1.3 其他同步机制
• 2 synchronized解释
• 2.1 内置锁工作原理
• 3 显式锁（Lock接口）
• 3.1 Lock接口的主要方法
• 3.2 使用示例
• 4 Lock接口与synchronized的区别
• 5 总结

大家好，我是欧阳方超，微信公众号同名。

1 同步的方式

1.1 synchronized关键字

在JDK1.5之前，synchronized关键字是实现同步的主要方式（另一种比较原始的方式是使用volatile关键字），它内置于Java语言中，是一种简单直接的同步机制，通过对方法或代码块进行修饰，利用对象的监视器（monitor）来控制线程访问共享资源，保证在同一时刻只有一个线程能够执行被synchronized包含的代码部分。synchronized被视为重量级锁，可能导致较大的性能开销，因为它会引起线程的阻塞和唤醒。

1.2 显式锁（Lock接口）

JDK1.5引入了JUC，也就是常说的Java并发包，该包提供了比传统synchronized关键字更灵活的锁机制，允许开发者在多线程环境中更好地控制对共享资源的访问，如ReentrantLock、ReadWriteLock等。

1.3 其他同步机制

在JDK 1.5之前，开发者还可以使用低级别的原子操作（如使用volatile关键字）来实现某些类型的同步，但这通常只适用于简单的状态标志，而不能替代复杂的同步需求。

2 synchronized解释

synchronized是基于intrinsic lock（也称monitor lock）实现的（所基于的这种东西有时也简称为monitor）。Java中，每个对象都有一个监视器与之关联。当一个线程要执行synchronized方法或代码块时，它必须先获取方法或代码块所属对象的内置锁，这确保了统一时刻只有一个线程能访问同步代码，因此阻止了并发访问。

2.1 内置锁工作原理

• 获取锁
  当一个线程要执行synchronized方法时，它必须首选获得与方法对应所在对象的monitor关联的内置锁。此时如果另一个线程已经拥有了这个锁，那么这个请求的线程一直被阻塞知道它能获得锁。
• 执行代码
  一旦线程获得了锁，就可以安全地执行synchronized方法或代码块。
• 释放锁
  线程执行完毕后，会在退出synchronized方法或代码块时自动释放锁，以便其他线程获得锁。
• 等待与唤醒
  每一个monitor都有一个与之关联的wait set（等待集），这里包含了那些等待条件满足后才能执行的线程。线程调用了对象的wait()方法后会进入到对象的wait set，并且在其他线程调用了相应对象的notify()或nofityAll()方法后，那些进入到wait set中的线程会被唤醒。
  下面通过示例理解一下：

import java.util.ArrayList;
import java.util.List;

public class WaitNotifyExample {

    public static void main(String[] args) {
        Warehouse warehouse = new Warehouse();
        Thread producerThread = new Thread(new Producer(warehouse));
        Thread consumerThread = new Thread(new Consumer(warehouse));
        producerThread.start();
        consumerThread.start();
    }
}

class Warehouse {
    private List<String> products = new ArrayList<>();
    public synchronized void produce(String product) {
        products.add(product);
        System.out.println("Produced: " + product);
        //生产了产品后，通知等待的消费者线程
        notifyAll();
    }

    public synchronized String consume() {
        while (products.isEmpty()) {
            try {
                System.out.println("Warehouse is empty, waiting for production...");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        String product = products.remove(0);
        System.out.println("Consumed: " + product);
        return product;
    }
}

class Producer implements Runnable {
    private Warehouse warehouse;
    public Producer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            String product = "Product " + i;
            warehouse.produce(product);
        }
    }

}

class Consumer implements Runnable {
    private Warehouse warehouse;
    public Consumer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            warehouse.consume();
        }
    }

}

下面是可能的输出结果：

Warehouse is empty, waiting for production...
Produced: Product 0
Produced: Product 1
Produced: Product 2
Produced: Product 3
Produced: Product 4
Produced: Product 5
Produced: Product 6
Consumed: Product 0
Consumed: Product 1
Consumed: Product 2
Consumed: Product 3
Consumed: Product 4
Consumed: Product 5
Consumed: Product 6
Warehouse is empty, waiting for production...
Produced: Product 7
Produced: Product 8
Produced: Product 9
Consumed: Product 7
Consumed: Product 8
Consumed: Product 9

程序的执行流程：

• 在Warehouse类的consume方法中，当products为空时，消费者线程调用wait()方法。这会导致当前线程释放Warehouse对象的锁（因为consume方法是synchronized的），然后进入等待状态，被放入Warehouse对象的等待集中。
• 此时，其他线程（如生产者线程）可以获取Warehouse对象的锁并执行produce方法。当生产者向products列表中添加产品后，调用notifyAll()方法，这个操作会唤醒在Warehouse对象等待集中的所有线程（在这个例子中主要是消费者线程）。
• 被唤醒的消费者线程会尝试重新获取Warehouse对象的锁。当获取到锁后，它会从wait()方法调用后的位置继续执行，也就是重新检查products是否为空（通过while循环），如果不为空，就从仓库中取出产品进行消费。

3 显式锁（Lock接口）

Lock接口提供了一种比传统synchronized关键字更灵活的锁机制，使得开发者能够更精确地控制线程的同步行为。该接口位于java.util.concurrent.locks包中，主要实现类是ReentrentLock。

3.1 Lock接口的主要方法

• void lock()：
  获取锁，如果锁已被其他线程持有，则当前线程会阻塞直到获取到锁。
• void lockInterruptibly()：
  可中断地获取锁，允许线程在等待锁时响应中断。
• boolean tryLock()：
  尝试获取锁，如果成功则返回true，否则返回false，不会阻塞。
• boolean tryLock(long time, TimeUnit unit)：
  尝试在指定的时间内获取锁，如果在超时时间内成功获取到锁则返回true，否则返回false。
• void unlock()：
  释放锁，必须在持有锁的情况下调用。
• Condition newCondition()：
  返回一个新的条件变量，用于线程间的通信。

3.2 使用示例

下面是一个使用ReentrantLock实现的简单示例，演示了如何使用Lock接口来控制线程访问共享资源。

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

public class LockExample {
    private static final Lock lock = new ReentrantLock();
    private static int sharedResource = 0;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> accessSharedResource("Thread-1"));
        Thread thread2 = new Thread(() -> accessSharedResource("Thread-2"));

        thread1.start();
        thread2.start();
    }

    private static void accessSharedResource(String threadName) {
        lock.lock(); // 获取锁
        try {
            System.out.println(threadName + " acquired the lock.");
            // 模拟对共享资源的访问
            sharedResource++;
            System.out.println(threadName + " updated shared resource to: " + sharedResource);
            Thread.sleep(5000); // 模拟延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
            System.out.println(threadName + " released the lock.");
        }
    }
}

下面是程序可能的输出结果：

Thread-1 acquired the lock.
Thread-1 updated shared resource to: 1
Thread-2 acquired the lock.
Thread-1 released the lock.
Thread-2 updated shared resource to: 2
Thread-2 released the lock.

解释一下为什么会出现这样的看似Thread-1和Thread-2交叉执行的情况，ReentrentLock与synchronized有所不同，对于synchronized块，如果一个线程进入了同步块，其他线程必须等待这个线程完全退出同步块（包括处理可能抛出的异常等）之后才能尝试进入，而ReentrentLock只会在Lock()方法处进行阻塞等待锁的释放，结合上述代码，当Thread-1执行完lock.unlock()后，Thread-2可能立马获取到锁了，所以打印出了"Thread-2 acquired the lock."，这也是ReentrentLock控制粒度更细的明证。

示例解析

• 创建锁：通过 ReentrantLock lock = new ReentrantLock(); 创建一个可重入锁。
• 获取和释放锁：在访问共享资源前调用 lock.lock() 来获取锁，并在访问结束后通过 lock.unlock() 释放锁。
• 异常处理：使用 try…finally 结构确保无论是否发生异常，都能正确释放锁。
• 多线程访问：启动两个线程并尝试同时访问共享资源，确保在同一时刻只有一个线程能够修改资源。

4 Lock接口与synchronized的区别

• 手动控制：与synchronized自动获取和释放锁不同，使用Lock需要手动调用 lock() 和 unlock()。
• 可中断性：通过 lockInterruptibly() 方法可以响应中断，而synchronized无法做到这一点。
• 尝试获取锁：可以使用 tryLock() 方法尝试非阻塞地获取锁，而synchronized会一直等待直到获得锁。
• 条件变量支持：通过 newCondition() 可以实现更复杂的线程间通信机制，而synchronized只能使用 wait() 和 notify()。

5 总结

在 Java 多线程编程中，同步机制至关重要。synchronized 关键字是早期实现同步的主要方式，基于对象的监视器锁，其原理是线程在执行被其修饰的方法或代码块时需先获取对应对象的内置锁，执行完毕后自动释放，且提供了等待与唤醒机制来处理线程间协作。然而，它存在性能开销大等问题，被视为重量级锁。JDK 1.5 引入的 Lock 接口则提供了更灵活的锁机制，以 ReentrantLock 为例，它的方法如 lock、lockInterruptibly、tryLock 等能让开发者更精准地控制锁的获取与释放，可响应中断且能尝试非阻塞地获取锁，同时通过 newCondition 方法支持更复杂的线程间通信，与 synchronized 在手动控制、可中断性、尝试获取锁以及条件变量支持等方面存在明显区别。