Detailed explanation of usage scenarios and functions of volatile keyword in Java

Detailed explanation of the role and application scenarios of the volatile keyword in Java

1. The role of the volatile keyword
In Java, the volatile keyword is used to identify a Variables are visible across multiple threads, i.e. visibility is guaranteed. Specifically, when a variable is declared volatile, any modifications to the variable are immediately known to other threads.

2. Application scenarios of volatile keyword

1. Status flag
   The volatile keyword is suitable for some status flag scenarios, such as one thread responsible for starting and stopping another thread. implement. The following is an example:

public class FlagThread {
    private volatile boolean running = true;
    
    public void setRunning(boolean running) {
        this.running = running;
    }
    
    public void run() {
        while (running) {
            // 执行任务
        }
        // 停止执行
    }
    
    public static void main(String[] args) {
        FlagThread thread = new FlagThread();
        thread.start();
        
        // 模拟运行一段时间后停止执行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        thread.setRunning(false);
    }
}

In the above code, the running variable in the FlagThread class is declared volatile. When the main thread sets running to false, the FlagThread thread immediately senses it and stops execution.

2. Double-checked locking in singleton mode
   In some cases, we need to ensure that when multiple threads access a variable at the same time, the variable is only initialized once. The following is an example of the singleton pattern implemented using double-checked locking:

public class Singleton {
    private volatile static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

In the above code, the instance variable is declared volatile. This is because in a multi-threaded environment, if the volatile keyword is not used, due to the problem of instruction reordering, when multiple threads access the getInstance method at the same time, the instance returned is not a fully initialized object.

3. Data sharing between two threads
   In multi-thread programming, the volatile keyword can also be used for data sharing between two threads. The following is an example:

public class SharedData {
    private volatile int data;
    
    public int getData() {
        return data;
    }
    
    public void setData(int data) {
        this.data = data;
    }
}

public class Producer implements Runnable {
    private SharedData sharedData;
    
    public Producer(SharedData sharedData) {
        this.sharedData = sharedData;
    }
    
    @Override
    public void run() {
        int value = 0;
        while (true) {
            sharedData.setData(value);
            value++;
        }
    }
}

public class Consumer implements Runnable {
    private SharedData sharedData;
    
    public Consumer(SharedData sharedData) {
        this.sharedData = sharedData;
    }
    
    @Override
    public void run() {
        while (true) {
            int value = sharedData.getData();
            System.out.println(value);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SharedData sharedData = new SharedData();
        Thread producerThread = new Thread(new Producer(sharedData));
        Thread consumerThread = new Thread(new Consumer(sharedData));
        
        producerThread.start();
        consumerThread.start();
    }
}

In the above code, the Producer thread continuously writes data to the data variable of the sharedData object, while the Consumer thread continuously reads data from the data variable. Since the data variable is declared volatile, the Producer thread's write operation to data is visible to the Consumer thread.

3. Summary
The volatile keyword plays an important role in Java multi-threaded programming. It is used to ensure the visibility of variables. In some scenarios, we need to ensure that modifications to variables between multiple threads are visible to other threads. In this case, the volatile keyword can be used. However, it should be noted that the volatile keyword can only guarantee visibility, but not the atomicity of variables. If you need to ensure atomicity, you can consider using the synchronized keyword or the Atomic class.

The above is the detailed content of Detailed explanation of usage scenarios and functions of volatile keyword in Java. For more information, please follow other related articles on the PHP Chinese website!