Java有哪些锁及怎么使用

前言

在多线程编程中，为了保证数据的正确性和并发性能的优化，我们需要使用锁来控制资源的访问。在Java中，提供了多种锁的实现，每种锁都有其特定的使用方式和适用场景。

1. synchronized关键字

synchronized关键字是Java中最基本的锁机制，它可以修饰方法和代码块。使用synchronized关键字修饰的对象或方法在同一时刻只能被一个线程访问，其他线程需要等待锁的释放才能继续执行。

使用synchronized关键字修饰方法：

public synchronized void method() {
    // synchronized代码块
    // ...
}

使用synchronized关键字修饰代码块：

public void method() {
    synchronized (lock) {
        // synchronized代码块
        // ...
    }
}

2. ReentrantLock

ReentrantLock是Java中提供的可重入互斥锁，相比于synchronized关键字，ReentrantLock提供了更灵活的锁操作，比如可以实现公平锁和非公平锁、可中断锁、定时锁等功能。

使用ReentrantLock：

ReentrantLock lock = new ReentrantLock();

public void method() {
    lock.lock();
    try {
        // 临界区代码
        // ...
    } finally {
        lock.unlock();
    }
}

3. ReadWriteLock

ReadWriteLock是一个读写锁，它允许多个线程同时执行读操作，但只允许一个线程执行写操作。这种锁适用于读多写少的场景，可以提高并发读的性能。

使用ReadWriteLock：

ReadWriteLock lock = new ReentrantReadWriteLock();

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

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

4. StampedLock

StampedLock是Java 8引入的新型锁，它支持乐观读、悲观读和写操作，并且在读锁的基础上提供了更高级别的优化。

使用StampedLock：

StampedLock lock = new StampedLock();

public void readMethod() {
    long stamp = lock.tryOptimisticRead();
    // 乐观读操作
    // ...
    if (!lock.validate(stamp)) {
        stamp = lock.readLock();
        try {
            // 悲观读操作
            // ...
        } finally {
            lock.unlockRead(stamp);
        }
    }
}

public void writeMethod() {
    long stamp = lock.writeLock();
    try {
        // 写操作
        // ...
    } finally {
        lock.unlockWrite(stamp);
    }
}

总结

Java提供了多种锁的实现，每种锁都有其适用的场景。使用锁可以保证资源的正确性和并发性能的优化。在选择锁的时候，要根据具体的业务需求和性能要求来进行选择，合理利用各种锁机制可以提高多线程程序的效率。