Java的锁机制详解

井九

发布于 2024-10-12 10:52:45

870

发布于 2024-10-12 10:52:45

文章被收录于专栏：四楼没电梯

在并发编程中，锁是用于控制多个线程对共享资源进行访问的工具。Java提供了多种锁机制，从最基础的 synchronized 到高级的 ReentrantLock，这些锁帮助我们确保线程安全，并能有效避免数据竞争和死锁问题。

1. synchronized 关键字

synchronized 是Java中最简单的锁机制。它可以锁住方法或者代码块，确保某个线程在访问共享资源时，其他线程无法访问同一个资源。

示例代码：同步方法

public class SynchronizedExample {
    public synchronized void synchronizedMethod() {
        System.out.println("Thread " + Thread.currentThread().getName() + " is executing synchronized method.");
    }
}

在上述代码中，synchronizedMethod 方法被 synchronized 关键字修饰，意味着同一时间只能有一个线程执行该方法。

示例代码：同步代码块

public class SynchronizedBlockExample {
    private final Object lock = new Object();

    public void synchronizedBlock() {
        synchronized (lock) {
            System.out.println("Thread " + Thread.currentThread().getName() + " is executing synchronized block.");
        }
    }
}

使用同步代码块可以灵活地锁定某个对象（如上例中的 lock），只锁住需要保护的部分，而不是整个方法。

锁的粒度问题

synchronized 锁的粒度较粗，可能会导致性能瓶颈。对于更复杂的并发场景，ReentrantLock 等更灵活的锁机制是更好的选择。

2. ReentrantLock

ReentrantLock 是 Java java.util.concurrent.locks 包中的高级锁，它提供了更丰富的功能，如：公平锁、可重入性、可中断锁 等。

2.1 基本使用

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void execute() {
        lock.lock(); // 获取锁
        try {
            System.out.println("Thread " + Thread.currentThread().getName() + " is executing.");
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

在这个例子中，我们显式地调用 lock.lock() 来获取锁，并在 finally 中确保锁会被释放，以防止因异常导致死锁。

2.2 公平锁

默认情况下，ReentrantLock 是非公平锁，即等待时间长的线程不一定优先获得锁。你可以通过构造函数指定是否为公平锁：

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

公平锁确保先请求锁的线程先获得锁，但相对性能较低。

3. ReadWriteLock

ReadWriteLock 是一种更细粒度的锁，它允许多个读线程同时访问共享资源，但在有写操作时，写线程会独占资源。典型的实现是 ReentrantReadWriteLock。

示例代码

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void read() {
        rwLock.readLock().lock();
        try {
            System.out.println("Thread " + Thread.currentThread().getName() + " is reading.");
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void write() {
        rwLock.writeLock().lock();
        try {
            System.out.println("Thread " + Thread.currentThread().getName() + " is writing.");
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

这种锁的优势在于读操作不互斥，当多个线程只读数据时，能够提高系统的吞吐量。但在写操作时，所有的读操作会被阻塞，确保数据的一致性。