synchronized 和 Lock 有什么区别？

synchronized 和 Lock 都是 Java 中用于实现线程同步的机制，它们都可以保证线程安全。

synchronized 介绍与使用

synchronized 可用来修饰普通方法、静态方法和代码块，当一个线程访问一个被 synchronized 修饰的方法或者代码块时，会自动获取该对象的锁，其他线程将会被阻塞，直到该线程执行完毕并释放锁。这样就保证了多个线程对共享资源的操作的互斥性，从而避免了数据的不一致性和线程安全问题。

synchronized 基本使用如下：

public class SynchronizedDemo {    private int count = 0;    public synchronized void increment() {        count++;    }    public synchronized int getCount() {        return count;    }}

此时我们再使用多线程调用上面类的 increment 或 getCount 时，就不会出现线程安全问题了，如下代码所示：

public class SynchronizedDemoTest {    public static void main(String[] args) {        SynchronizedDemo demo = new SynchronizedDemo();        Runnable r = () -> {            for (int i = 0; i < 1000; i++) {                demo.increment();            }        };
        Thread t1 = new Thread(r);        Thread t2 = new Thread(r);
        t1.start();        t2.start();
        try {            t1.join();            t2.join();        } catch (InterruptedException e) {            e.printStackTrace();        }
        System.out.println("Count: " + demo.getCount());    }}

Lock 介绍与使用

Lock 是一种线程同步的机制，它与 synchronized 相似，可以用于控制对共享资源的访问。相比于 synchronized，Lock 的特点在于更加灵活，支持更多的操作。

Lock 接口定义了以下方法：

• lock()：获取锁，如果锁已被其他线程占用，则阻塞当前线程。

• tryLock()：尝试获取锁，如果锁已被其他线程占用，则返回 false，否则返回 true。

• tryLock(long timeout, TimeUnit unit)：尝试获取锁，在指定的时间范围内获取到锁则返回 true，否则返回 false。

• unlock()：释放锁。

相比于 synchronized，Lock 的优点在于：

• 粒度更细：synchronized 关键字只能对整个方法或代码块进行同步，而 Lock 可以对单个变量或对象进行同步。

• 支持公平锁：synchronized 不支持公平锁，而 Lock 可以通过构造函数指定锁是否是公平锁。

• 支持多个条件变量：Lock 可以创建多个条件变量，即多个等待队列。

Lock 的实现类有很多，比较常用的有 ReentrantLock 和 ReentrantReadWriteLock。

需要注意的是，使用 Lock 时需要手动获取和释放锁，否则会导致死锁等问题。因此，一般来说建议使用 try-finally 语句块来确保锁的正确释放。例如：

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;
public class Counter {    private int count = 0;    private Lock lock = new ReentrantLock();
    public void increment() {        // 加锁        lock.lock();        try {            count++;        } finally {            // 释放锁            lock.unlock();        }    }
    public void decrement() {        // 加锁        lock.lock();        try {            count--;        } finally {            // 释放锁            lock.unlock();        }    }    public int getCount() {        return count;    }}

synchronized VS Lock

synchronized 和 Lock 主要的区别有以下几个方面：

1. 锁的获取方式：synchronized 是隐式获取锁的，即在进入 synchronized 代码块或方法时自动获取锁，退出时自动释放锁；而 Lock 需要程序显式地获取锁和释放锁，即需要调用 lock() 方法获取锁，调用 unlock() 方法释放锁。

2. 锁的性质：synchronized 是可重入的互斥锁，即同一个线程可以多次获得同一把锁，而且锁的释放也只能由获得锁的线程来释放；Lock 可以是可重入的互斥锁，也可以是非可重入的互斥锁，还可以是读写锁。

3. 锁的粒度：synchronized 是以代码块和方法为单位进行加锁和解锁，而 Lock 可以精确地控制锁的范围，可以支持多个条件变量。

4. 性能：在低并发的情况下，synchronized 的性能优于 Lock，因为 Lock 需要显式地获取和释放锁，而 synchronized 是在 JVM 层面实现的；在高并发的情况下，Lock 的性能可能优于 synchronized，因为 Lock 可以更好地支持高并发和读写分离的场景。

总的来说，synchronized 的使用更加简单，但是在某些场景下会受到性能的限制；而 Lock 则更加灵活，可以更精确地控制锁的范围和条件变量，但是使用起来比较繁琐。需要根据具体的业务场景和性能需求来选择使用哪种锁机制。

本文已收录至《Java 面试突击》，专注 Java 面试 100 年，查看更多：www.javacn.site