Introduction to the volatile keyword in Java concurrent programming (with examples)

This article brings you an introduction to the volatile keyword in Java concurrent programming (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

volatile-Explanation

• The role of the volatile keyword is that the variable is visible in multiple threads;

• The volatile keyword is not Atomic

• If you want to implement atomic operations, it is recommended to use a series of objects of the atomic class: support atomic operations (note that the atomic class only guarantees the atomicity of its own method, and does not guarantee multiple times. Atomicity of the operation)

1. volatile :

• The role of the volatile keyword is that the variable is visible in multiple threads;

Example:RunThread.java
Explanation:In Java, each thread will have a working memory area, which stores information shared by all threads. A copy of the variable in main memory. When the thread executes, these variables are manipulated in its own working memory area. In order to access a shared variable, a thread usually first obtains the lock and clears the memory working area of ​​the current thread, and correctly loads these shared variables from the shared memory area of ​​all threads into its own working memory area. Thread unlocking ensures that the values ​​of variables in the working memory are written to the shared memory area.

• * The operations that a thread can perform are: use (use), assignment (assgin), load (load), store (store), lock (lock), unlock (unlock) ;

• * The operations that can be performed in main memory are: read (read), write (write), lock (lock), unlock (unlock); each operation is atomic of.

• * The function of volatile is to force the thread to read variables in the main memory (shared memory) instead of reading in the thread working memory area, thus realizing multiple threads The variables between are visible. This also satisfies thread-safe visibility;

public class RunThread extends Thread{

    private volatile boolean isRunning = true;
    private void setRunning(boolean isRunning){
        this.isRunning = isRunning;
    }

    public void run(){
        System.out.println("进入run方法..");
        int i = 0;
        while(isRunning == true){
            //..
        }
        System.out.println("线程停止");
    }

    public static void main(String[] args) throws InterruptedException {
        RunThread rt = new RunThread();
        rt.start();
        Thread.sleep(1000);
        rt.setRunning(false);
        System.out.println("isRunning的值已经被设置了false");
    }
}

2. The volatile keyword is non-atomic. Although the volatile keyword has visibility between multiple threads, , but it does not have synchronization (that is, atomicity). It can be regarded as a lightweight synchronized. The performance is much better than synchronized and will not cause blocking (in many open source architectures: Netty's underlying code is volatile when used extensively. Visible netty performance)

• * Things to note: Generally volatile is used for variable operations visible to multiple threads, and cannot replace the synchronization effect of synchronized;

Example: concurrent.java

Description: The
volatile keyword only has visibility and no atomicity.

import java.util.concurrent.atomic.AtomicInteger;
/**
* volatile关键字不具备synchronized关键字的原子性（同步）
* @@author Maozw
*
*/
public class VolatileNoAtomic extends Thread{
    //private static volatile int count;
    private static AtomicInteger count = new AtomicInteger(0);
    private static void addCount(){
      for (int i = 0; i < 1000; i++) {
        //count++ ;
        count.incrementAndGet();
      }
      System.out.println(count);
    }

    public void run(){
      addCount();
    }

    public static void main(String[] args) {

      VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
      for (int i = 0; i < 10; i++) {
        arr[i] = new VolatileNoAtomic();
      }

      for (int i = 0; i < 10; i++) {
        arr[i].start();
      }
    }
}

* If you want to implement atomic operations, it is recommended to use a series of objects of the atomic class: support atomic operations (note that the atomic class only guarantees the atomicity of its own method and does not guarantee multiple operations. atomicity)

Example:

Description:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicUse {

private static AtomicInteger count = new AtomicInteger(0);

    //多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修饰，保证4个addAndGet整体原子性
    /**synchronized*/
    public synchronized int multiAdd(){
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        count.addAndGet(1);
        count.addAndGet(2);
        count.addAndGet(3);
        count.addAndGet(4); //+10
        return count.get();
    }
    public static void main(String[] args) {

      final AtomicUse au = new AtomicUse();

      List<Thread> ts = new ArrayList<Thread>();
      for (int i = 0; i < 100; i++) {
        ts.add(new Thread(new Runnable() {
          @Override
          public void run() {
            System.out.println(au.multiAdd());
          }
        }));
      }
      for(Thread t : ts){
        t.start();
      }
    }
}

The above is the detailed content of Introduction to the volatile keyword in Java concurrent programming (with examples). For more information, please follow other related articles on the PHP Chinese website!