Javatpoint Logo
Javatpoint Logo

Atomic Boolean in Java

Java, a versatile and popular programming language, offers a wide range of tools and data structures to help developers create efficient, reliable, and thread-safe applications. One such tool in the Java Concurrency framework is the Atomic Boolean. In this section, we will explore what is Atomic Boolean, why it's useful, and provide examples with full code explanations to showcase its practical applications.

What is an Atomic Boolean?

An Atomic Boolean is a part of the Java java.util.concurrent.atomic package, which provides atomic operations for various data types. In essence, an Atomic Boolean is a boolean variable that can be atomically updated. Atomic operations ensure that multiple threads can safely access and modify the value of this boolean without interference or race conditions.

Why use Atomic Boolean?

When working with multi-threaded applications, ensuring data consistency and preventing race conditions is crucial. A race condition occurs when two or more threads attempt to modify a shared variable simultaneously, leading to unpredictable and erroneous behavior. Atomic Boolean comes to the rescue in such scenarios by providing thread-safe operations on boolean variables. Here are a few reasons why you might consider using Atomic Boolean:

  1. Thread Safety: Atomic Boolean provides thread-safe operations, ensuring that only one thread can modify the value at a time. This eliminates the need for manual synchronization, reducing the potential for deadlocks and other concurrency issues.
  2. Performance: While synchronization mechanisms like synchronized blocks or locks introduce overhead, Atomic Boolean operations are typically more efficient since they leverage low-level hardware support for atomic operations.
  3. Simple and Readable: Atomic Boolean operations are simple and easy to understand. This can lead to more readable code, making it easier for developers to reason about concurrency.
  4. Fine-Grained Control: We can control the level of atomicity precisely. You can choose to use methods like compareAndSet(), allowing you to update the value based on a condition, or use straightforward set and get operations.

Atomic Boolean in Action

Let's dive into some practical examples of how to use Atomic Boolean in Java, starting with the basics.

Example 1: Creating an Atomic Boolean

In this example, we'll create an Atomic Boolean, set its initial value to true, and demonstrate how to toggle it between true and false using two threads. We'll print the state of the Atomic Boolean after each toggle operation.


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

In this example, we create an Atomic Boolean named flag with an initial value of true. Two threads (thread1 and thread2) are used to toggle the flag between true and false. The output shows that despite concurrent operations, the Atomic Boolean ensures that the final value is true.

Example 2: Using compareAndSet() Method

The compareAndSet() method allows you to update the Atomic Boolean based on a condition. If the condition is met, the update occurs atomically. Let's illustrate this with an example where two threads try to set the Atomic Boolean to false, but only one of them succeeds.


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

In this example, thread1 successfully sets the flag to false, and thread2 fails because the compareAndSet() method checks the condition and updates the Atomic Boolean atomically.

Example 3: Real-World Scenario

Let's consider a real-world scenario where multiple threads need to coordinate their actions using Atomic Boolean. We will simulate a door that can be opened and closed by multiple threads, ensuring that the door is not opened by multiple threads simultaneously.


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

In this example, we have an Atomic Boolean named doorOpen that ensures only one thread can open the door at a time. If a thread tries to open the door when it's already open, it's notified and cannot proceed.

Atomic Boolean in Advanced Use Cases

1. Counting Semaphores with Atomic Boolean:

Atomic Boolean can be used to create simple counting semaphores, which allow a fixed number of threads to access a resource concurrently. By using an Atomic Boolean to guard access to the resource, you can ensure that only a specific number of threads can access it at any given time.


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.

In this example, the Counting Semaphore uses an Atomic Boolean to keep track of available permits. When a thread calls acquire, it checks the Atomic Boolean to determine if it can proceed. If the semaphore has available permits, it sets the Atomic Boolean to false to indicate that one permit has been acquired. When a thread calls release, it resets the Atomic Boolean to true, releasing the permit.

2. Timeouts and Atomic Boolean:

Atomic Boolean can be used in conjunction with timers and timeouts. Consider a scenario where you want to execute a task for a limited time and stop it if it exceeds the allowed time. You can use Atomic Boolean to signal when the task should stop running.


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.

In this example, we create a task that runs until the stopFlag is set to true. We use an Atomic Boolean to control when the task should stop, and a timeout mechanism to set the stopFlag after a specified duration.

we'll implement a "stopwatch" that can be started, paused, resumed, and reset using an Atomic Boolean.


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

In this example, we've created a StopwatchExample class. The stopwatch thread continuously updates the elapsed time when the stopwatch is running. It sleeps for 100 milliseconds between updates to simulate time passing. The main thread starts, pauses, resumes, and eventually stops the stopwatch. The program simulates the functionality of a stopwatch using AtomicBoolean to control the running state. You can see how the AtomicBoolean ensures that the stopwatch updates its time correctly when running, pauses when needed, and eventually calculates and displays the elapsed time.

Considerations When Using Atomic Boolean

1. Visibility and Volatility:

It's important to understand that Atomic Boolean provides atomicity for individual operations but doesn't inherently guarantee visibility. To ensure that changes to an Atomic Boolean are visible to other threads, you may need to use the volatile keyword in addition to Atomic Boolean.

Using volatile with Atomic Boolean ensures that changes made to the Atomic Boolean by one thread are immediately visible to other threads.

2. Race Conditions and Deadlocks:

While Atomic Boolean helps prevent certain types of race conditions, it doesn't make your code immune to all concurrency issues. You must still be cautious and consider the broader context of your program. Improper usage of Atomic Boolean can lead to deadlocks or livelocks, so careful design is crucial.

3. Use Cases for Atomic Boolean:

Atomic Boolean is well-suited for scenarios where you need to coordinate actions between multiple threads and require a simple binary state (e.g., on/off, true/false). For more complex states or operations, you may need other atomic types such as AtomicInteger or AtomicReference.

4. Concurrent Collections:

When working with collections in a multi-threaded environment, consider using concurrent collections provided by the java.util.concurrent package. These collections are designed for thread-safe operations and can simplify the management of concurrent data.

5. Testing and Debugging:

Thoroughly test your multi-threaded code and use debugging tools, such as thread dumps and profilers, to identify and resolve issues. Concurrent programming can be challenging, and diagnosing problems can be complex.

In Summary, The Atomic Boolean is a valuable tool in Java's concurrency framework, providing a simple and efficient way to handle boolean values in multi-threaded applications. It ensures thread safety, promotes performance, and offers fine-grained control over atomic operations. While this article introduced you to the basics of Atomic Boolean, there are many other atomic classes in Java's java.util.concurrent.atomic package for handling different data types. Understanding and using these classes appropriately can greatly enhance the efficiency and reliability of your concurrent Java applications.

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA