Java并发编程：互斥锁（上）：解决原子性问题

用心去追梦

于 2024-08-16 10:36:45 发布

阅读量312

点赞数 3

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_33240556/article/details/141253136

版权

在Java并发编程中，互斥锁是一种常用的同步机制，用于解决原子性问题。互斥锁可以确保同一时刻只有一个线程能够访问某个共享资源或执行一段临界区代码。下面我将详细介绍互斥锁的概念及其在Java中的实现方式，并通过示例代码来展示如何使用互斥锁来解决原子性问题。

1. 互斥锁概念

互斥锁（Mutual Exclusion Lock，简称Mutex锁）是一种保证同一时刻只有一个线程可以访问共享资源的机制。当一个线程获取了锁之后，其他试图获取该锁的线程会被阻塞，直到持有锁的线程释放锁为止。互斥锁可以分为两种类型：

独占锁（Exclusive Lock）：一次只能被一个线程持有。
共享锁（Shared Lock）：允许多个线程同时持有，但通常只允许读操作。

在Java中，最常见的互斥锁实现有两种：

内置锁（Synchronized）：通过synchronized关键字实现，可以作用于方法或代码块。
显示锁（ReentrantLock）：通过java.util.concurrent.locks.Lock接口的实现类ReentrantLock实现。

2. 内置锁（Synchronized）

内置锁是最简单的互斥锁实现，它可以作用于方法或代码块。当一个线程进入synchronized代码块或方法时，它会自动获取锁；当线程退出时，锁会被自动释放。

示例代码

public class Counter {

    private int count = 0;

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

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

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

public class SynchronizedCounterDemo {

    public static void main(String[] args) {
        final Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.decrement();
            }
        });

        thread1.start();
        thread2.start();

        // 等待所有线程完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + counter.value());
    }
}

在这个示例中，我们定义了一个Counter类，其中的increment()、decrement()和value()方法都使用了synchronized关键字。这样可以确保在任何时候只有一个线程可以访问这些方法，从而解决了原子性问题。

3. 显示锁（ReentrantLock）

显示锁提供了更灵活的锁管理方式，例如可以显式地获取和释放锁，还可以支持公平性和非公平性的选择。

示例代码

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {

    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

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

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

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

public class ReentrantLockCounterDemo {

    public static void main(String[] args) {
        final ReentrantLockCounter counter = new ReentrantLockCounter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.decrement();
            }
        });

        thread1.start();
        thread2.start();

        // 等待所有线程完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + counter.value());
    }
}