Java锁机制：并发安全的核心保障

概述

锁是Java并发编程的核心机制，它保证了多线程环境下共享资源的安全访问。

1. synchronized锁

public class SynchronizedDemo {
    private int count = 0;

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

    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
}

2. ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
    private final ReentrantLock lock = new ReentrantLock();
    private int balance = 1000;

    public void transfer(int amount) {
        lock.lock();
        try {
            if (balance >= amount) {
                balance -= amount;
            }
        } finally {
            lock.unlock();
        }
    }

    // 公平锁
    private final ReentrantLock fairLock = new ReentrantLock(true);

    // 尝试获取锁
    public void tryTransfer(int amount) {
        if (fairLock.tryLock()) {
            try {
                balance -= amount;
            } finally {
                fairLock.unlock();
            }
        }
    }
}

3. ReadWriteLock

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private Map<String, String> map = new HashMap<>();

    public String get(String key) {
        lock.readLock().lock();
        try {
            return map.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    public void put(String key, String value) {
        lock.writeLock().lock();
        try {
            map.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

4. StampedLock

import java.util.concurrent.locks.StampedLock;

public class StampedLockDemo {
    private final StampedLock lock = new StampedLock();
    private double x, y;

    public double distanceFromOrigin() {
        long stamp = lock.tryOptimisticRead();
        double currentX = x;
        double currentY = y;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try { currentX = x; currentY = y; }
            finally { lock.unlockRead(stamp); }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    public void move(double deltaX, double deltaY) {
        long stamp = lock.writeLock();
        try { x += deltaX; y += deltaY; }
        finally { lock.unlockWrite(stamp); }
    }
}

5. 死锁

public class DeadlockDemo {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) { }
        }
    }

    public void method2() {
        synchronized (lock2) {
            synchronized (lock1) { }
        }
    }
}

最佳实践

1. 减少锁的粒度：只锁必要的代码
2. 避免死锁：注意锁的获取顺序
3. 使用读写锁：读多写少场景使用ReadWriteLock
4. 设置超时时间：避免长时间等待锁
5. 使用synchronized：简单场景优先使用

总结

锁是Java并发编程的核心机制，掌握synchronized、ReentrantLock、ReadWriteLock等锁的使用，可以保证多线程环境下共享资源的安全访问。