Synchronized和Lock的区别

超、凢脫俗 2024-04-24 23:03 99阅读 0赞

`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` 接口通常会提供更好的控制和更高的灵活性。