Java中synchronized 和 Lock

1. `synchronized` 关键字

工作原理

对象锁：在Java中，每个对象都有一个与之关联的监视器锁（monitor lock）。当一个线程尝试进入由 synchronized 保护的代码块或方法时，它必须首先获取该对象的监视器锁。如果锁已经被其他线程持有，则该线程将被阻塞，直到锁被释放。
类锁：对于静态同步方法来说，锁定的是这个类对应的Class对象，而不是实例对象。这意味着所有实例共享同一把锁。

内部机制

对象头与Mark Word：
- 每个Java对象都有一个对象头，其中包含了Mark Word。根据不同的锁状态（无锁、偏向锁、轻量级锁、重量级锁），Mark Word的内容会发生变化。
  - 无锁状态：包含对象的哈希值或GC年龄。
  - 偏向锁状态：适用于单线程访问场景，减少不必要的CAS操作。偏向锁会在对象头中记录偏向的线程ID。如果后续请求依旧来自同一线程，则无需再次获取锁。
  - 轻量级锁状态：采用基于CAS的操作来尝试获取锁，避免直接进入重量级锁带来的性能损耗。轻量级锁通过在当前线程的栈帧中创建一个锁记录，并使用CAS操作尝试更新对象头中的Mark Word来实现。
  - 重量级锁状态：如果竞争加剧，JVM会将锁膨胀为重量级锁。此时涉及到操作系统层面的调度，线程会被挂起等待锁的释放。
锁升级过程：包括偏向锁、轻量级锁到重量级锁的转换过程，旨在减少线程获取锁的成本。锁升级的过程是自动的，不需要开发者干预。偏向锁 -> 轻量级锁 -> 重量级锁的升级路径是为了优化性能，在低竞争条件下尽可能地减少开销。

特性

自动管理：进入同步代码块或方法时自动获取锁，退出时自动释放锁，不需要手动操作。
不可中断：一旦一个线程开始等待获取 synchronized 锁，则无法被中断，直到成功获得锁或当前线程结束。
公平性：不保证获取锁的顺序，可能会导致某些线程长时间等待（饥饿现象）。
支持重入：同一个线程可以多次获取同一个锁而不会造成死锁。这是通过计数器机制实现的，每次获取锁时计数器加一，释放锁时减一，当计数器归零时才真正释放锁。
可见性和有序性：提供内存屏障功能，确保了一个线程对共享变量所做的修改，在其释放锁之后，能够立即对随后获取同一把锁的其他线程可见，并防止指令重排序。

示例代码

public class SynchronizedExample {
    private int count = 0;

    // 同步方法
    public synchronized void increment() {
        count++;
    }

    // 同步代码块
    public void incrementWithBlock() {
        synchronized (this) {
            count++;
        }
    }

    // 静态同步方法
    public static synchronized void staticIncrement(SynchronizedExample instance) {
        instance.count++;
    }

    // 使用双重检查锁定模式初始化单例
    private static volatile SynchronizedExample singletonInstance;
    //双重检查锁定模式是一种高效的单例实现方式，它结合了懒加载、线程安全和性能优化的优点。通过                 
    //volatile 和双重检查机制，可以确保在多线程环境下只创建一个实例，同时避免不必要的同步开销。


    public static SynchronizedExample getInstance() {
        if (singletonInstance == null) {
            synchronized (SynchronizedExample.class) {
                if (singletonInstance == null) {
                    singletonInstance = new SynchronizedExample();
                }
            }
        }
        return singletonInstance;
    }
}

双重检查锁定模式详解

为什么需要双重检查锁定？

性能优化：如果直接使用 synchronized 方法或代码块进行单例初始化，每次访问实例时都会进入同步代码块，这会导致性能开销较大。
懒加载：只有在第一次访问实例时才进行初始化，而不是在类加载时就创建实例。
线程安全：确保多个线程同时访问时不会创建多个实例。

双重检查锁定的核心思想是：

在第一次检查 singletonInstance == null 时，避免进入同步块。
在第二次检查 singletonInstance == null 时，确保只有一个线程能够创建实例。

实现步骤

第一次检查：在获取锁之前，先检查实例是否已经存在。如果已经存在，则直接返回实例，避免进入同步块。
加锁：如果实例尚未创建，则进入同步块。
第二次检查：在同步块内再次检查实例是否已经存在。这是为了防止多个线程同时通过第一次检查后都尝试创建实例。
创建实例：如果实例仍然为 null，则创建实例并赋值给静态变量。

代码示例

以下是完整的双重检查锁定模式实现单例的示例代码：

public class Singleton {
    // 使用 volatile 确保实例的可见性和防止指令重排序
    private static volatile Singleton instance;

    // 私有构造函数，防止外部实例化
    private Singleton() {
        // 防止反射攻击（可选）
        if (instance != null) {
            throw new RuntimeException("Use getInstance() method to get the single instance.");
        }
    }

    // 提供全局访问点
    public static Singleton getInstance() {
        // 第一次检查：避免不必要的同步
        if (instance == null) {
            synchronized (Singleton.class) {
                // 第二次检查：确保只有一个线程能创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // 测试方法
    public void showMessage() {
        System.out.println("Hello from Singleton instance!");
    }

    public static void main(String[] args) {
        // 多线程测试
        Runnable task = () -> {
            Singleton singleton = Singleton.getInstance();
            singleton.showMessage();
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();
    }
}

代码解析

volatile 关键字的作用：
- 确保 instance 的可见性：当一个线程修改了 instance 的值，其他线程能够立即看到最新的值。
- 防止指令重排序：在 JVM 中，对象的创建可能被分解为以下步骤：
  1. 分配内存空间。
  2. 初始化对象。
  3. 将引用指向分配的内存地址。如果没有 volatile，JVM 可能会因为指令重排序导致其他线程看到一个未完全初始化的对象。
双重检查的意义：
- 第一次检查：减少同步的开销。如果实例已经存在，直接返回，避免进入同步块。
- 第二次检查：确保只有一个线程能够创建实例，即使多个线程同时通过了第一次检查。
私有构造函数：
- 防止外部通过 new Singleton() 创建新的实例。
- 可以进一步增强安全性，防止反射攻击。
多线程测试：
- 通过两个线程同时调用 getInstance() 方法，验证是否只有一个实例被创建。

运行结果

运行上述代码时，输出结果类似如下（顺序可能不同）：

Hello from Singleton instance!
Hello from Singleton instance!

尽管有两个线程同时调用 getInstance() 方法，但只会创建一个 Singleton 实例。

注意事项

volatile 是必需的：
- 如果不使用 volatile，可能会因为指令重排序导致其他线程看到未完全初始化的对象，从而引发问题。
反射攻击：
- 即使使用了私有构造函数，仍然可以通过反射机制强制调用构造函数创建新的实例。可以在构造函数中添加检查逻辑来防止这种情况。
序列化问题：
- 如果单例类实现了 Serializable 接口，反序列化时可能会创建新的实例。可以通过定义 readResolve() 方法解决此问题：
```
protected Object readResolve() {
    return instance;
}
```

2. 显式锁 (`Lock` 接口)

工作原理

显式调用：需要显式地调用 lock() 方法来获取锁，并在finally块中调用 unlock() 方法来释放锁。
多种锁机制：提供了比 synchronized 更多的锁机制，如可重入锁、读写锁等。

特性

灵活性高：可以通过编程控制何时锁定、解锁，允许尝试获取锁、定时获取锁等操作。
可中断：可以中断正在等待获取锁的线程，避免了潜在的阻塞问题。例如，lockInterruptibly() 方法允许你中断正在等待获取锁的线程。
公平性选择：可以选择是否启用公平锁（先请求的线程优先获得锁），有助于防止饥饿现象。例如，new ReentrantLock(true) 创建一个公平锁。
多种条件变量：支持多个条件变量（Condition），比 synchronized 的单一条件通知机制更为灵活。例如，你可以使用 newCondition() 方法创建多个条件变量。
支持重入：同样支持重入，即同一个线程可以多次获取同一个锁。这也是通过计数器机制实现的。

示例代码

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

public class LockExample {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private int count = 0;

    // 使用显式锁进行同步
    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 确保在finally块中释放锁，避免死锁
        }
    }

    // 条件变量的使用
    public void awaitAndSignal() throws InterruptedException {
        lock.lock();
        try {
            System.out.println("Before await");
            condition.await(); // 当前线程等待
            System.out.println("After await");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断标志
        } finally {
            lock.unlock();
        }

        lock.lock();
        try {
            condition.signal(); // 唤醒等待的线程
        } finally {
            lock.unlock();
        }
    }

    // 尝试获取锁并设置超时时间
    public void incrementWithTimeout() throws InterruptedException {
        if (lock.tryLock(1, TimeUnit.SECONDS)) { // 尝试获取锁，最多等待1秒
            try {
                count++;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("Unable to acquire lock");
        }
    }

    // 可中断锁获取
    public void incrementInterruptibly() throws InterruptedException {
        lock.lockInterruptibly(); // 可以响应中断的锁获取
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    // 使用公平锁
    public static void fairLockExample() {
        Lock fairLock = new ReentrantLock(true); // 创建一个公平锁
        // 使用fairLock进行同步操作
    }
}

实际应用中的最佳实践

简单同步需求：如果你只需要对方法或代码块进行简单的同步处理，synchronized 是一个不错的选择，因为它简单且不易出错。
复杂同步需求：如果你需要更多的控制，比如定时锁等待、可中断锁等待或公平锁等高级功能，那么 Lock 接口将是更好的选择。
锁细化：尽量缩小同步区域范围，以减少线程之间的争用，提高并发效率。
双重检查锁定：在单例模式中常用，减少同步开销。双重检查锁定是一种优化技术，用于延迟初始化单例对象，减少同步开销。
使用显式锁：如 ReentrantLock, ReadWriteLock 提供了比 synchronized 更灵活的锁机制。特别是 ReadWriteLock 可以允许多个线程同时读取数据，但只允许一个线程写入数据。
避免死锁：确保所有线程以相同的顺序获取锁，避免循环等待的情况发生。例如，定义一个全局的锁获取顺序，并严格遵守该顺序。

注意事项

性能对比：虽然 synchronized 在很多情况下表现良好，但对于某些复杂的并发场景，显式锁（如 ReentrantLock）可能提供更好的性能和更大的灵活性。
异常处理：在使用显式锁时，务必在finally块中释放锁，以防止因异常而导致死锁。
调试技巧：利用日志或调试工具监控锁的状态和线程的行为，可以帮助诊断并发问题。