并发编程AtomicBoolean详解

AtomicBoolean 是 Java 中的一种原子变量类，提供了对布尔值进行原子操作的能力。它是 java.util.concurrent.atomic 包的一部分，使用了 CAS（Compare-And-Swap）机制来实现无锁的并发控制。AtomicBoolean 常用于需要以线程安全的方式对布尔值进行读写操作的场景。以下是 AtomicBoolean 的常见使用场景和示例。
常见使用场景
1. 状态标志：

public class Task implements Runnable {
    private final AtomicBoolean running = new AtomicBoolean(false);

    public void start() {
        if (running.compareAndSet(false, true)) {
            new Thread(this).start();
        }
    }

    public void run() {
        while (running.get()) {
            // 执行任务
        }
    }

    public void stop() {
        running.set(false);
    }
}

AtomicBoolean 常用作状态标志，确保多个线程之间可以正确地看到状态的变化。例如，控制一个线程是否应该停止运行。
一次性初始化：

public class Singleton {
    private static final AtomicBoolean initialized = new AtomicBoolean(false);

    public static void initialize() {
        if (initialized.compareAndSet(false, true)) {
            // 执行一次性初始化操作
        }
    }
}

AtomicBoolean 可用于实现一次性初始化操作，确保某个操作在并发环境下只执行一次。
乐观锁：

public class OptimisticLock {
    private final AtomicBoolean lock = new AtomicBoolean(false);

    public boolean tryLock() {
        return lock.compareAndSet(false, true);
    }

    public void unlock() {
        lock.set(false);
    }
}

在一些情况下，AtomicBoolean 可以用来实现乐观锁，防止多个线程同时执行冲突的操作。
控制并发访问：

public class Resource {
    private final AtomicBoolean inUse = new AtomicBoolean(false);

    public void useResource() {
        if (inUse.compareAndSet(false, true)) {
            try {
                // 使用资源
            } finally {
                inUse.set(false);
            }
        } else {
            // 资源正在使用中
        }
    }
}

AtomicBoolean 可以用于控制对资源或代码块的并发访问，确保同一时间只有一个线程可以访问。
非阻塞算法：

public class NonBlockingAlgorithm {
    private final AtomicBoolean flag = new AtomicBoolean(false);

    public void performTask() {
        if (flag.compareAndSet(false, true)) {
            try {
                // 执行任务
            } finally {
                flag.set(false);
            }
        } else {
            // 任务正在执行中
        }
    }
}

AtomicBoolean 常用于实现非阻塞算法，提供一种高效的并发控制手段。
示例代码
以下是一个使用 AtomicBoolean 控制任务执行的示例：

import java.util.concurrent.atomic.AtomicBoolean;

public class TaskController {
    private final AtomicBoolean running = new AtomicBoolean(false);

    public void startTask() {
        if (running.compareAndSet(false, true)) {
            new Thread(() -> {
                while (running.get()) {
                    try {
                        // 模拟任务
                        Thread.sleep(1000);
                        System.out.println("Task is running");
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }).start();
        } else {
            System.out.println("Task is already running");
        }
    }

    public void stopTask() {
        running.set(false);
        System.out.println("Task is stopped");
    }

    public static void main(String[] args) throws InterruptedException {
        TaskController controller = new TaskController();
        controller.startTask();
        Thread.sleep(3000);
        controller.stopTask();
    }
}

在这个示例中，AtomicBoolean 用于控制任务的启动和停止，确保任务在并发环境下可以正确地控制其运行状态。
总结
AtomicBoolean 是一种高效的原子变量类，适用于需要以线程安全的方式对布尔值进行操作的场景。它提供了状态标志、一次性初始化、乐观锁、控制并发访问和非阻塞算法等常见使用场景。理解和正确使用 AtomicBoolean，有助于编写高效且正确的并发程序。