引言

在 Java 并发编程的世界里，synchronized 和 Lock 是两把“锁”，它们守护着多线程环境下的数据安全。但你知道它们的区别吗？谁的性能更好？谁更适合高并发场景？今天，【代码方程式】带你深入探讨这场“锁”事之争，揭秘它们的底层原理与实战应用！

1. synchronized：老牌锁的坚守

synchronized 是 Java 中最常用的锁机制，它的使用简单直接，但背后却隐藏着许多细节。

• 特点：
• 内置锁：JVM 原生支持，无需额外引入依赖。
• 自动释放：锁在代码块执行完毕后自动释放，无需手动管理。
• 可重入：同一个线程可以多次获取同一把锁。
• 使用场景：
• 简单的同步需求，如单例模式、计数器等。
• 适合低并发场景，代码简洁易维护。
• 示例：

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

• 缺点：
• 性能瓶颈：在高并发场景下，竞争激烈时性能下降明显。
• 功能单一：不支持超时、中断等高级功能。

2. Lock：灵活锁的崛起

Lock 是 Java 5 引入的接口，它的实现类（如 ReentrantLock）提供了更灵活的锁机制。

• 特点：
• 显式锁：需要手动加锁和释放锁。
• 可中断：支持线程中断，避免死锁。
• 超时机制：可以设置获取锁的超时时间。
• 公平锁：支持公平锁和非公平锁。
• 使用场景：
• 高并发场景，如秒杀系统、分布式锁。
• 需要更细粒度的锁控制。
• 示例：

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();
        }
    }
}

• 缺点：
• 复杂度高：需要手动管理锁的获取和释放，容易遗漏 unlock。
• 代码冗余：相比 synchronized，代码量更多。

3. synchronized vs Lock：性能对比

在高并发场景下，Lock 的性能通常优于 synchronized，原因如下：

• 锁粒度：Lock 支持更细粒度的锁控制，减少锁竞争。
• 非阻塞机制：Lock 支持尝试获取锁（tryLock），避免线程阻塞。
• 公平性：Lock 支持公平锁，减少线程饥饿问题。
• 测试场景：
• 我们将模拟一个高并发的环境，启动多个线程来访问共享资源，并分别使用 synchronized 和 Lock 进行同步。
• 我们会测试两种方式在执行相同任务时的性能差异。

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

public class SynchronizedVsLockTest {

    private static final int THREAD_COUNT = 1000;
    private static final int INCREMENT_COUNT = 10000;
    
    // 共享资源
    private static int counter = 0;

    // 使用 synchronized 关键字
    public synchronized static void incrementSynchronized() {
        counter++;
    }

    // 使用 ReentrantLock
    private static final Lock lock = new ReentrantLock();
    public static void incrementLock() {
        lock.lock();
        try {
            counter++;
        } finally {
            lock.unlock();
        }
    }

    // 测试 synchronized
    public static void testSynchronized() {
        long startTime = System.currentTimeMillis();
        Thread[] threads = new Thread[THREAD_COUNT];
        
        for (int i = 0; i < thread_count i threadsi='new' thread -> {
                for (int j = 0; j < INCREMENT_COUNT; j++) {
                    incrementSynchronized();
                }
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        long endTime = System.currentTimeMillis();
        System.out.println("Synchronized Test Completed in: " + (endTime - startTime) + " ms");
    }

    // 测试 Lock
    public static void testLock() {
        long startTime = System.currentTimeMillis();
        Thread[] threads = new Thread[THREAD_COUNT];
        
        for (int i = 0; i < thread_count i threadsi='new' thread -> {
                for (int j = 0; j < INCREMENT_COUNT; j++) {
                    incrementLock();
                }
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        long endTime = System.currentTimeMillis();
        System.out.println("Lock Test Completed in: " + (endTime - startTime) + " ms");
    }

    public static void main(String[] args) {
        System.out.println("Starting Synchronized Test...");
        testSynchronized();
        
        // Reset counter for the next test
        counter = 0;

        System.out.println("Starting Lock Test...");
        testLock();
    }
}

解释：

1. 共享资源：counter 用来模拟需要同步的资源，所有线程都会对它进行自增操作。
2. incrementSynchronized()：通过 synchronized 关键字同步 counter 的修改。
3. incrementLock()：通过 ReentrantLock 显式加锁来同步 counter 的修改。
4. 测试流程：创建多个线程，每个线程执行一定次数的自增操作。分别测试 synchronized 和 Lock 的执行时间。记录并打印每种同步方式的执行时长。

执行流程：

1. 启动多个线程，每个线程进行多个自增操作。
2. 记录执行开始时间和结束时间，计算总共运行时长。

结果：

Starting Synchronized Test...
Synchronized Test Completed in: 2500 ms
Starting Lock Test...
Lock Test Completed in: 2000 ms

4. 如何选择：synchronized 还是 Lock？

• 选择 synchronized：
• 简单的同步需求。
• 低并发场景。
• 希望代码简洁易维护。
• 选择 Lock：
• 高并发场景。
• 需要更灵活的锁控制（如超时、中断）。
• 需要公平锁或读写锁。

5. 实战建议

• 避免死锁：无论是 synchronized 还是 Lock，都要注意锁的顺序，避免死锁。
• 锁粒度优化：尽量减小锁的粒度，提高并发性能。
• 工具支持：使用工具（如 JProfiler）分析锁竞争情况，优化性能。

结语

synchronized 和 Lock 各有优劣，选择哪种锁取决于具体的业务场景和性能需求。作为【代码方程式】的读者，希望你通过本文能够更好地理解它们的区别，并在实际开发中灵活运用。

你对 synchronized 和 Lock 有什么使用心得？欢迎在评论区分享你的看法！

互动环节

1. 投票：你在项目中更常用哪种锁？（A. synchronized B. Lock）
2. 话题讨论：在高并发场景下，你认为哪种锁更适合？为什么？
3. 福利：关注【代码方程式】，获取2025最新java面试题！