当前位置：首页 > article >正文

并发操作下如何加锁，自动释放锁，异常情况可以主动释放锁

article 2025/2/28 20:20:31

在Java中，处理并发操作时，加锁是一个常见的需求，以确保线程安全。Java提供了多种机制来实现锁的控制，包括synchronized关键字、ReentrantLock类等。下面我将介绍如何使用这些机制来加锁、自动释放锁以及在异常情况下主动释放锁。

使用 `synchronized` 关键字

synchronized 是Java中最基本的加锁机制，它可以用来修饰方法或代码块。

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

在这个例子中，increment 和 getCount 方法都被 synchronized 修饰，这意味着同一时间只有一个线程可以执行这些方法。锁会在方法执行完毕后自动释放。

使用 `ReentrantLock`

ReentrantLock 是 java.util.concurrent.locks 包中的一个类，它提供了比 synchronized 更灵活的锁操作。

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

public class Counter {
    private final Lock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();  // 加锁
        try {
            count++;
        } finally {
            lock.unlock();  // 确保锁被释放
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

在这个例子中，我们使用 ReentrantLock 来手动加锁和释放锁。lock.lock() 用于加锁，lock.unlock() 用于释放锁。为了确保锁在异常情况下也能被释放，我们将 unlock() 放在 finally 块中。

自动释放锁

无论是 synchronized 还是 ReentrantLock，锁都会在代码块执行完毕后自动释放。对于 synchronized，锁会在方法或代码块执行完毕后释放；对于 ReentrantLock，锁会在 unlock() 被调用时释放。

异常情况下主动释放锁

在使用 ReentrantLock 时，如果发生异常，我们可以在 finally 块中调用 unlock() 来确保锁被释放。例如：

public void riskyMethod() {
    lock.lock();
    try {
        // 可能抛出异常的代码
        if (someCondition) {
            throw new RuntimeException("Something went wrong!");
        }
    } finally {
        lock.unlock();  // 确保锁被释放
    }
}