java 锁一个变量

原创

mob649e81586edc 2023-08-10 10:59:27 ©著作权

©著作权归作者所有：来自51CTO博客作者mob649e81586edc的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 锁一个变量

在多线程编程中，经常会遇到多个线程同时访问和修改同一个变量的情况。为了避免数据不一致或者竞态条件的问题，我们需要使用锁机制来保证变量的安全性和一致性。Java 提供了多种锁的实现，本文将介绍如何使用锁来保护一个变量，并提供相应的代码示例。

锁的概念

在并发编程中，锁是一种同步机制，用于控制对共享资源的访问。当一个线程获取到锁后，其他线程需要等待锁的释放才能继续访问共享资源。锁的主要目的是保护共享资源的完整性和一致性。

在 Java 中，锁可以分为两种类型：悲观锁和乐观锁。悲观锁（Pessimistic Lock）假设并发访问会导致冲突，因此在访问共享资源之前先获取锁。乐观锁（Optimistic Lock）假设并发访问不会导致冲突，因此可以不加锁直接访问共享资源，并在提交修改时检查是否有冲突。

在本文中，我们将重点介绍悲观锁的使用方式。

锁的实现

Java 提供了多种类型的锁，常用的有 synchronized 关键字和 ReentrantLock 类。下面分别介绍这两种锁的使用方式。

使用 synchronized 关键字

synchronized 关键字是 Java 中最基本的锁机制，可以修饰方法或代码块。使用 synchronized 关键字修饰的代码片段称为临界区，同一时刻只能有一个线程执行该代码片段。

以下是使用 synchronized 关键字保护一个变量的示例代码：

public class SynchronizedExample {
    private int count = 0;

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

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

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

在上述代码中，通过在方法前加上 synchronized 关键字，保证了对 count 变量的访问和修改是线程安全的。即使有多个线程同时调用 increment()、decrement() 或 getCount() 方法，也不会导致数据不一致的问题。

使用 ReentrantLock 类

ReentrantLock 是 Java 提供的可重入锁实现，相比于 synchronized 关键字，它提供了更灵活的锁操作。需要注意的是，ReentrantLock 需要手动控制锁的获取和释放。

以下是使用 ReentrantLock 类保护一个变量的示例代码：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

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

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

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

在上述代码中，通过调用 lock() 方法获取锁，使用 try-finally 块确保在任何情况下都能释放锁。与 synchronized 关键字不同，ReentrantLock 允许在不同的代码块中获取和释放锁，更加灵活。