java多线程怎样用锁机制

在 Java 中，多线程的锁机制主要用于保证共享资源的线程安全。下面从常见锁类型 → 使用示例 → 使用建议系统讲一下。

一、Java 中常见的锁机制

1️⃣ synchronized（内置锁 / 隐式锁）

最基础、最常用的锁。

修饰方法

public synchronized void add() {
    count++;
}

修饰代码块（更推荐）

private final Object lock = new Object();

public void add() {
    synchronized (lock) {
        count++;
    }
}

✅ 特点：

• 自动加锁 / 释放锁（JVM 管理）
• 可重入
• 非公平锁

2️⃣ ReentrantLock（显示锁）

java.util.concurrent.locks 提供

ReentrantLock lock = new ReentrantLock();

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

✅ 特点：

• 可中断
• 可设置公平锁
• 可尝试获取锁（tryLock）

3️⃣ ReadWriteLock（读写锁）

适合读多写少场景

ReadWriteLock rwLock = new ReentrantReadWriteLock();

public void read() {
    rwLock.readLock().lock();
    try {
        // 读操作
    } finally {
        rwLock.readLock().unlock();
    }
}

public void write() {
    rwLock.writeLock().lock();
    try {
        // 写操作
    } finally {
        rwLock.writeLock().unlock();
    }
}

4️⃣ StampedLock（乐观读锁，JDK 8+）

性能更高，适合高并发读

StampedLock lock = new StampedLock();

long stamp = lock.tryOptimisticRead();
// 读
if (!lock.validate(stamp)) {
    stamp = lock.readLock();
    try {
        // 重新读
    } finally {
        lock.unlockRead(stamp);
    }
}

5️⃣ volatile（不是锁，但常配合用）

保证可见性，不保证原子性

private volatile boolean flag = false;

二、典型多线程加锁示例

示例：多线程计数

class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

三、锁的使用建议（非常重要）

✅ 锁的粒度尽量小

synchronized(lock) {
    // 只包必要代码
}

✅ 锁对象必须是 final

private final Object lock = new Object();

✅ 避免在锁中调用外部方法 防止死锁

✅ 优先用并发工具类

• AtomicInteger
• ConcurrentHashMap
• CountDownLatch

四、死锁示例（避免）

synchronized(a) {
    synchronized(b) {
    }
}

✅ 解决：

• 固定加锁顺序
• 使用 tryLock

五、总结对比

如果你愿意，我可以：

• 帮你写 完整多线程示例
• 讲 死锁排查方法
• 对比 synchronized vs Lock 源码层面

你更想深入哪一块？