Synchronized和Lock的区别

synchronized 和 Lock 都是 Java 中用于实现线程同步的机制，但它们之间存在一些关键的区别和细节。

synchronized

synchronized 是 Java 内置的同步机制。它基于监视器锁（monitor lock）或对象锁概忈实现，当线程进入一个 synchronized 方法或代码块时，它会自动获得锁，退出时自动释放锁。

特点

• 内置语法: 不需要显式创建锁对象。
• 自动锁管理: 锁的获取和释放由 JVM 管理。
• 阻塞和唤醒: 当线程尝试获取一个已被其他线程持有的锁时，它会阻塞，并在锁被释放时自动唤醒。
• 可重入: 支持同一线程的多次加锁。
• 不支持中断: 当线程在等待锁时，不能响应中断。
• 没有公平性: 不能保证等待时间最长的线程会首先获得锁。
• 性能: 在 JDK 1.6 之后，通过引入偏向锁、轻量级锁、重量级锁等优化，性能得到显著提升。

示例代码

public class SynchronizedExample {
    private int count = 0;

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

    // 块同步
    public void decrement() {
        synchronized(this) {
            count--;
        }
    }
}

Lock 接口

Lock 是一个接口，它提供了比 synchronized 更灵活的锁操作，并且允许更细粒度的锁控制。ReentrantLock 是 Lock 的一个常用实现类。

特点

• 显示锁操作: 需要手动获取和释放锁。
• 尝试获取锁: 提供了 tryLock() 方法，可以尝试获取锁而不会无限期等待。
• 中断锁等待: 线程可以在等待锁的过程中响应中断。
• 公平锁支持: 可选的公平锁模式可以保证先进先出的服务顺序。
• 锁绑定多个条件: 可以绑定多个条件对象，实现复杂的同步机制。

示例代码

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

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

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

    public void decrement() {
        if (lock.tryLock()) {
            try {
                count--;
            } finally {
                lock.unlock();
            }
        }
    }
}

比较

1. 可中断性: 使用 Lock，线程在等待锁的过程中可以被中断。与 synchronized 不同，一个等待 synchronized 块的线程不能被中断。
2. 公平性: Lock 提供了可选的公平性设置，例如，ReentrantLock 支持创建公平锁和非公平锁，而 synchronized 不支持公平锁。
3. 条件变量: Lock 提供了 Condition 类，可以分离对象锁的等待集，而 synchronized 与 Object 类的 wait()、notify()、notifyAll() 方法一起工作，只有一个条件（等待集），可能不够细粒度。
4. 锁绑定: Lock 可以跨方法绑定锁，而 synchronized 锁定的范围受到方法或代码块的限制。

内部实现

synchronized 实现

synchronized 的实现涉及 JVM 底层的监视器锁（monitor）。在对象锁的情况下，每个对象都与一个监视器相关联，当 synchronized 方法或代码块被执行时，线程必须获得这个监视器。

// 伪代码展示 synchronized 实现的概念
monitor.enter(object) // 进入同步块
try {
    // 同步代码
} finally {
    monitor.exit(object) // 退出同步块
}

Lock 实现

Lock 接口的实现通常涉及 AQS（AbstractQueuedSynchronizer）的使用。ReentrantLock 就是通过这种方式实现的。

// 伪代码展示 Lock 实现的概念
public class ReentrantLock implements Lock {
    private final Sync sync = new Sync();

    private static class Sync extends AbstractQueuedSynchronizer {
        // 实现 AQS 提供的方法来定义锁的行为
    }

    public void lock() {
        sync.acquire(1);
    }

    public void unlock() {
        sync.release(1);
    }

    // 其他方法...
}

ReentrantLock 通过扩展 AQS 并实现相应的方法，如 tryAcquire() 和 tryRelease()，来管理其锁状态。

总结

synchronized 适合简单的同步场景，它是 Java 语言级的特性。由于 JDK 的优化，它在性能上有了显著提升，对大多数情况下足够好。

相比之下，Lock 提供的灵活性更高，它是显式的、可控的，并且拥有更多的特性。如果需要高级功能，比如可中断的锁获取、公平性、以及绑定多个条件，那么 Lock 通常是更好的选择。

选择哪一种同步方式取决于具体的应用场景和需求。在涉及复杂同步控制逻辑或特殊需求时，Lock 接口通常会提供更好的控制和更高的灵活性。