Java volatile的几种使用场景分析

public class TaskRunner implements Runnable {
    private volatile boolean running = true;  // 状态标志，控制任务是否继续执行

    public void run() {
        while (running) {  // 检查状态标志
            // 执行任务
            doSomething();
        }
    }

    public void stop() {
        running = false;  // 修改状态标志，使得线程能够停止执行
    }

    private void doSomething() {
        // 实际任务逻辑
    }
}

public class Singleton {
    // 使用 volatile 保证实例的可见性和有序性
    private static volatile Singleton instance;

    private Singleton() {
    }
    
    public static Singleton getInstance() {
        if (instance == null) {  // 第一次检查，避免不必要的同步
            synchronized (Singleton.class) {  // 锁定
                if (instance == null) {  // 第二次检查，确保只创建一次实例
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class VolatileTest {  
    private volatile int value;  
    
    //读，不加锁，提供效率 
    public int getValue() {   
        return value;   
    }   
    //写操作，使用锁，保证线程安全  
    public synchronized int increment() {  
        return value++;  
    }  
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class DataStructure {
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final Object data = ...; // 被保护的数据

    public void read() {
        readWriteLock.readLock().lock(); // 获取读锁
        try {
            // 执行读操作
            // 例如，读取data的内容
        } finally {
            readWriteLock.readLock().unlock(); // 释放读锁
        }
    }

    public void write(Object newData) {
        readWriteLock.writeLock().lock(); // 获取写锁
        try {
            // 执行写操作
            // 例如，修改data的内容
        } finally {
            readWriteLock.writeLock().unlock(); // 释放写锁
        }
    }
}