synchronized 是 Java 关键字，简单易用、自动释放锁；Lock 是 JUC 包下的接口（常用实现 ReentrantLock），功能更灵活，但需要手动释放锁，稍复杂。

1. synchronized 用法（简单，自动释放）

public class SyncDemo {
    // 共享资源
    private int count = 0;

    // synchronized 修饰方法
    public synchronized void increment() {
        count++;
    }

    // synchronized 代码块（更灵活）
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }

    public int getCount() {
        return count;
    }
}

优点：不用管释放，代码简洁，新手不易出错。
缺点：如果获取锁的线程卡住，其他线程只能一直等，没有退路。

2. Lock 用法（灵活，手动释放）

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

public class LockDemo {
    private int count = 0;
    // 创建可重入锁（公平锁：new ReentrantLock(true)）
    private final Lock lock = new ReentrantLock();

    public void increment() {
        // 加锁
        lock.lock();
        try {
            count++; // 核心逻辑
        } finally {
            // 必须在 finally 中释放，避免异常导致锁泄漏
            lock.unlock();
        }
    }

    // 尝试获取锁（不会死等）
    public boolean tryDecrement() {
        // 尝试获取锁，1秒内获取不到就放弃
        if (lock.tryLock(1, java.util.concurrent.TimeUnit.SECONDS)) {
            try {
                count--;
                return true;
            } finally {
                lock.unlock();
            }
        }
        return false; // 获取锁失败
    }

    public int getCount() {
        return count;
    }
}

两者都是可重入锁：同一个线程可以多次获取同一把锁，不会自己锁死自己。

// synchronized 可重入
public synchronized void methodA() {
    methodB(); // 同一个线程调用，不会死锁
}
public synchronized void methodB() {}

// Lock 可重入
public void methodC() {
    lock.lock();
    try {
        methodD();
    } finally {
        lock.unlock();
    }
}
public void methodD() {
    lock.lock();
    try { /* 逻辑 */ } finally { lock.unlock(); }
}

总结

• synchronized：关键字、自动释放、简单易用，适合大部分基础同步场景。
• Lock：接口、手动释放（必写 finally）、功能丰富（尝试获取 / 超时 / 公平锁），适合复杂并发场景。