Java 中的 Atomic Boolean

2024年9月10日 | 阅读 9 分钟

Java 是一种通用且流行的编程语言，它提供了广泛的工具和数据结构，帮助开发人员创建高效、可靠且线程安全的应用程序。Java 并发框架中的一个此类工具就是 Atomic Boolean。在本节中，我们将探讨 什么是 Atomic Boolean，它有什么用处， 并提供带有完整代码解释的示例来展示其实际应用。

什么是 Atomic Boolean？

Atomic Boolean 是 Java java.util.concurrent.atomic 包的一部分，该包为各种数据类型提供了原子操作。本质上，Atomic Boolean 是一个可以原子更新的布尔变量。原子操作确保多个线程可以安全地访问和修改此布尔值，而不会发生干扰或竞态条件。

为什么要使用 Atomic Boolean？

在处理多线程应用程序时，确保数据一致性和防止竞态条件至关重要。当两个或多个线程同时尝试修改共享变量时，就会发生竞态条件，导致不可预测和错误的行为。在这种情况下，Atomic Boolean 通过提供对布尔变量的线程安全操作来发挥作用。以下是您可能考虑使用 Atomic Boolean 的几个原因：

线程安全： Atomic Boolean 提供线程安全操作，确保一次只有一个线程可以修改该值。这消除了手动同步的需要，减少了死锁和其他并发问题的可能性。
性能： 虽然 synchronized 块或锁等同步机制会带来开销，但 Atomic Boolean 操作通常更有效，因为它们利用了低级硬件对原子操作的支持。
简单易读： Atomic Boolean 操作简单易懂。这可以使代码更具可读性，使开发人员更容易理解并发。
细粒度控制： 我们可以精确控制原子性级别。您可以选择使用 compareAndSet() 等方法，允许您根据条件更新值，或者使用简单的 set 和 get 操作。

Atomic Boolean 实战

让我们深入研究一些如何在 Java 中使用 Atomic Boolean 的实际示例，从基础开始。

示例 1：创建 Atomic Boolean

在此示例中，我们将创建一个 Atomic Boolean，将其初始值设置为 true，并演示如何使用两个线程在 true 和 false 之间切换它。我们将打印每次切换操作后 Atomic Boolean 的状态。

AtomicBooleanExample.java

import java.util.concurrent.atomic.AtomicBoolean ;
public class AtomicBooleanExample {
    public static void main(String[] args) {
        Atomic Boolean  flag = new Atomic Boolean (true);
        // Thread 1 toggles the flag from true to false
        Thread thread1 = new Thread(() -> {
            flag.set(false);
            System.out.println("Thread 1: Set flag to false");
        });
        // Thread 2 toggles the flag from false to true
        Thread thread2 = new Thread(() -> {
            flag.set(true);
            System.out.println("Thread 2: Set flag to true");
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final flag value: " + flag.get());
    }
}

输出

Thread 1: Set flag to false
Thread 2: Set flag to true
Final flag value: true

在此示例中，我们创建了一个名为 flag 的 Atomic Boolean，其初始值为 true。使用两个线程（thread1 和 thread2）在 true 和 false 之间切换 flag。输出显示，尽管存在并发操作，Atomic Boolean 确保最终值为 true。

示例 2：使用 compareAndSet() 方法

compareAndSet() 方法允许您根据条件更新 Atomic Boolean。如果满足条件，则原子地执行更新。让我们通过一个示例来说明这一点，其中两个线程都尝试将 Atomic Boolean 设置为 false，但只有一个成功。

AtomicBooleanExample2.java

import java.util.concurrent.atomic.AtomicBoolean ;
public class AtomicBooleanExample2 {
    public static void main(String[] args) {
        Atomic Boolean  flag = new Atomic Boolean (true);
        // Thread 1 tries to set the flag to false
        Thread thread1 = new Thread(() -> {
            if (flag.compareAndSet(true, false)) {
                System.out.println("Thread 1: Set flag to false");
            } else {
                System.out.println("Thread 1: Failed to set flag to false");
            }
        });
        // Thread 2 also tries to set the flag to false
        Thread thread2 = new Thread(() -> {
            if (flag.compareAndSet(true, false)) {
                System.out.println("Thread 2: Set flag to false");
            } else {
                System.out.println("Thread 2: Failed to set flag to false");
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final flag value: " + flag.get());
    }
}

输出

Thread 1: Set flag to false
Thread 2: Failed to set flag to false
Final flag value: false

在此示例中，thread1 成功将 flag 设置为 false，而 thread2 失败，因为 compareAndSet() 方法检查条件并原子地更新 Atomic Boolean。

示例 3：实际场景

让我们考虑一个实际场景，其中多个线程需要使用 Atomic Boolean 来协调它们的动作。我们将模拟一扇门，多个线程可以打开和关闭它，确保门不会被多个线程同时打开。

DoorExample.java

import java.util.concurrent.atomic.AtomicBoolean ;
public class DoorExample {
    public static void main(String[] args) {
        Atomic Boolean  doorOpen = new Atomic Boolean (false);
        Runnable openDoor = () -> {
            if (doorOpen.compareAndSet(false, true)) {
                System.out.println("Door opened by Thread " + Thread.currentThread().getId());
                try {
                    Thread.sleep(1000); // Simulating some activity
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                doorOpen.set(false); // Close the door
                System.out.println("Door closed by Thread " + Thread.currentThread().getId());
            } else {
                System.out.println("Door is already open. Thread " + Thread.currentThread().getId() + " couldn't open it.");
            }
        };
        Thread thread1 = new Thread(openDoor);
        Thread thread2 = new Thread(openDoor);
        Thread thread3 = new Thread(openDoor);
        thread1.start();
        thread2.start();
        thread3.start();
        try {
            thread1.join();
            thread2.join();
            thread3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出

Door opened by Thread 11
Door is already open. Thread 12 couldn't open it.
Door is already open. Thread 13 couldn't open it.
Door closed by Thread 11

在此示例中，我们有一个名为 doorOpen 的 Atomic Boolean，它确保一次只有一个线程可以打开门。如果一个线程尝试在门已打开时打开它，它将收到通知并且无法继续。

Atomic Boolean 的高级用例

1. 带 Atomic Boolean 的计数信号灯

Atomic Boolean 可用于创建简单的计数信号灯，它允许固定数量的线程并发访问资源。通过使用 Atomic Boolean 来保护对资源的访问，您可以确保在任何给定时间只有一个特定数量的线程可以访问它。

CountingSemaphore.java

public class SemaphoreExample {
    public static void main(String[] args) {
        CountingSemaphore semaphore = new CountingSemaphore(2);
        Thread thread1 = new Thread(() -> {
            if (semaphore.acquire()) {
                System.out.println("Thread 1 acquired a permit.");
                try {
                    Thread.sleep(1000); // Simulate some work
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                semaphore.release();
                System.out.println("Thread 1 released the permit.");
            }
        });
        Thread thread2 = new Thread(() -> {
            if (semaphore.acquire()) {
                System.out.println("Thread 2 acquired a permit.");
                try {
                    Thread.sleep(1000); // Simulate some work
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                semaphore.release();
                System.out.println("Thread 2 released the permit.");
            }
        });
        Thread thread3 = new Thread(() -> {
            if (semaphore.acquire()) {
                System.out.println("Thread 3 acquired a permit.");
                semaphore.release();
                System.out.println("Thread 3 released the permit.");
            }
        });
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

输出

Thread 1 acquired a permit.
Thread 2 acquired a permit.
Thread 3 acquired a permit.
Thread 1 released the permit.
Thread 2 released the permit.
Thread 3 released the permit.

在此示例中，计数信号灯使用 Atomic Boolean 来跟踪可用许可证。当线程调用 acquire 时，它会检查 Atomic Boolean 以确定是否可以继续。如果信号灯有可用许可证，它会将 Atomic Boolean 设置为 false，表示已获取一个许可证。当线程调用 release 时，它会将 Atomic Boolean 重置为 true，释放许可证。

2. 超时和 Atomic Boolean

Atomic Boolean 可与计时器和超时结合使用。考虑一个场景，您希望在有限的时间内执行任务，并在超过允许时间时停止它。您可以使用 Atomic Boolean 来发出任务应停止运行的信号。

TimeoutExample.java

import java.util.concurrent.atomic.AtomicBoolean;
public class TimeoutExample {
    public static void main(String[] args) {
        AtomicBoolean stopFlag = new AtomicBoolean(false);
        // Start a task
        Thread task = new Thread(() -> {
            int i = 1;
            while (!stopFlag.get()) {
                System.out.println("Task is running, iteration: " + i);
                i++;
                try {
                    Thread.sleep(1000); // Simulate some work by sleeping for a second
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Task has stopped.");
        });
        task.start();
        // Set a timeout to stop the task after 5 seconds
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        stopFlag.set(true); // Signal the task to stop
    }
}

输出

Task is running, iteration: 1
Task is running, iteration: 2
Task is running, iteration: 3
Task is running, iteration: 4
Task is running, iteration: 5
Task has stopped.

在此示例中，我们创建了一个运行直到 stopFlag 设置为 true 的任务。我们使用 Atomic Boolean 来控制任务何时停止，并使用超时机制在指定持续时间后设置 stopFlag。

我们将实现一个可以使用 Atomic Boolean 来启动、暂停、恢复和重置的“秒表”。

StopwatchExample.java

import java.util.concurrent.atomic.AtomicBoolean;
public class StopwatchExample {
    public static void main(String[] args) {
        AtomicBoolean isRunning = new AtomicBoolean(false);
        Thread stopwatch = new Thread(() -> {
            long startTime = 0;
            long elapsedTime = 0;
            while (true) {
                if (isRunning.get()) {
                    if (startTime == 0) {
                        startTime = System.currentTimeMillis() - elapsedTime;
                    }
                    elapsedTime = System.currentTimeMillis() - startTime;
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        stopwatch.start();
        // Start the stopwatch
        System.out.println("Starting the stopwatch.");
        isRunning.set(true);
        try {
            Thread.sleep(2000); // Let the stopwatch run for 2 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Pause the stopwatch
        System.out.println("Pausing the stopwatch.");
        isRunning.set(false);
        try {
            Thread.sleep(1500); // Pause for 1.5 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Resume the stopwatch
        System.out.println("Resuming the stopwatch.");
        isRunning.set(true);
        try {
            Thread.sleep(3000); // Let the stopwatch run for an additional 3 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Stop and reset the stopwatch
        System.out.println("Stopping and resetting the stopwatch.");
        isRunning.set(false);
        // Let's see the elapsed time
        long elapsedSeconds = stopwatch.getElapsedSeconds();
        System.out.println("Elapsed time: " + elapsedSeconds + " seconds.");
    }
}

输出

Starting the stopwatch.
Pausing the stopwatch.
Resuming the stopwatch.
Stopping and resetting the stopwatch.
Elapsed time: 5 seconds.

在此示例中，我们创建了一个 StopwatchExample 类。秒表线程在秒表运行时持续更新经过的时间。它在更新之间睡眠 100 毫秒以模拟时间的流逝。主线程启动、暂停、恢复，并最终停止秒表。该程序使用 AtomicBoolean 来控制运行状态，从而模拟秒表的功能。您可以看到 AtomicBoolean 如何确保秒表在运行时正确更新其时间，在需要时暂停，并最终计算和显示经过的时间。

使用 Atomic Boolean 时的注意事项

1. 可见性和易变性

重要的是要理解，Atomic Boolean 为单个操作提供了原子性，但并不固有地保证可见性。为了确保一个线程对 Atomic Boolean 所做的更改对其他线程可见，除了 Atomic Boolean 之外，您可能还需要使用 volatile 关键字。

使用 volatile 和 Atomic Boolean 确保一个线程对 Atomic Boolean 所做的更改对其他线程立即可见。

2. 竞态条件和死锁

虽然 Atomic Boolean 有助于防止某些类型的竞态条件，但它并不能使您的代码免疫所有并发问题。您仍需谨慎，并考虑程序的整体上下文。Atomic Boolean 的不当使用可能导致死锁或活锁，因此仔细设计至关重要。

3. Atomic Boolean 的用例

Atomic Boolean 非常适合需要协调多个线程之间的操作并且需要简单二进制状态（例如，开/关，真/假）的场景。对于更复杂的状态或操作，您可能需要其他原子类型，例如 AtomicInteger 或 AtomicReference。

4. 并发集合

在多线程环境中处理集合时，请考虑使用 java.util.concurrent 包提供的并发集合。这些集合专为线程安全操作而设计，可以简化并发数据的管理。

5. 测试和调试

彻底测试您的多线程代码，并使用调试工具，例如线程转储和性能分析器，来识别和解决问题。并发编程可能具有挑战性，诊断问题也可能很复杂。

总而言之，Atomic Boolean 是 Java 并发框架中的一个宝贵工具，它提供了一种简单有效的方法来处理多线程应用程序中的布尔值。它确保线程安全，提高性能，并提供对原子操作的细粒度控制。虽然本文介绍了 Atomic Boolean 的基础知识，但 Java 的 java.util.concurrent.atomic 包中还有许多其他原子类可用于处理不同的数据类型。正确理解和使用这些类可以大大提高并发 Java 应用程序的效率和可靠性。

下一主题Java 中的 Bitset 类

Java 中的 Atomic Boolean

什么是 Atomic Boolean？

为什么要使用 Atomic Boolean？

Atomic Boolean 实战

示例 1：创建 Atomic Boolean

示例 2：使用 compareAndSet() 方法

示例 3：实际场景

Atomic Boolean 的高级用例

1. 带 Atomic Boolean 的计数信号灯

2. 超时和 Atomic Boolean

使用 Atomic Boolean 时的注意事项

1. 可见性和易变性

2. 竞态条件和死锁

3. Atomic Boolean 的用例

4. 并发集合

5. 测试和调试

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的 Atomic Boolean

什么是 Atomic Boolean？

为什么要使用 Atomic Boolean？

Atomic Boolean 实战

示例 1：创建 Atomic Boolean

示例 2：使用 compareAndSet() 方法

示例 3：实际场景

Atomic Boolean 的高级用例

1. 带 Atomic Boolean 的计数信号灯

2. 超时和 Atomic Boolean

使用 Atomic Boolean 时的注意事项

1. 可见性和易变性

2. 竞态条件和死锁

3. Atomic Boolean 的用例

4. 并发集合

5. 测试和调试

相关帖子

Java 中的回溯

Java 中多线程、多任务处理和多进程的区别

Java EE vs Node.js

Executor Framework Java

Java 中的数组分区问题

Java 8 StringJoiner、String.join() 和 Collectors.joining()

Java 中线段树的懒惰传播

如何在 Java 中获取文件类型

Java 中字符串转字符数组

Java 中的可移植性是什么

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器