Java并發編程之volatile關鍵字的案例

小編給大家分享一下Java并發編程之volatile關鍵字的案例，希望大家閱讀完這篇文章后大所收獲，下面讓我們一起去探討吧！

volatile-說明

• volatile關鍵字的作用是變量在多個線程可見；

• volatile 關鍵字是非原子性的

• 要是實現原子性操作，建議使用atomic類的系列對象：支持原子性操作（注意atomic類只保證本身方法的原子性，并不保證多次操作的原子性）

1. volatile :

• volatile關鍵字的作用是變量在多個線程可見；

示例：RunThread.java
說明：在Java中，每個線程都會有一個工作內存區域，其中存放所有線程共享的主內存中的變量的值得拷貝。當線程執行的時候，在自己的工作內存區域中操作這些變量。為了存取一個共享的變量，一個線程通常先獲得鎖定并清除當前線程的內存工作區域，把這些共享變量從所有線程的共享內存區域中正確的裝入到本身所以在的工作內存區域中，當線程解鎖是保證該工作內存中的變量的值寫會到共享內存區域中。

• *  一個線程可以執行的操作有：使用（use），賦值(assgin)，裝載（load），存儲(store)，鎖定(lock)，解鎖（unlock）;

• * 主內存中可以執行的操作有：讀(read)，寫(write)，鎖定(lock)，解鎖（unlock）; 每個操作都是原子性的。

• * volatile 的作用就是強制線程到主內存（共享內存）中去讀取變量，而不是去線程工作內存區域里去讀取，從而實現了多個線程間的變量可見。也就滿足了線程安全的可見性；

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. volatile 關鍵字是非原子性的

volatile 關鍵字雖然擁有多個線程之間的可見性，但是卻不具備同步性(也就是原子性)，可以算是一個輕量級的synchronized，性能要不synchronized強很多，不會造成阻塞(很多開源架構里面：netty的底層代碼大量使用可volatile，可見netty性能)

• * 需要注意的事：一般volatile用于多個線程可見的變量操作，并不能替代synchronized的同步作用；

示例：concurrent.java
說明：volatile 關鍵字只具有可見性，沒有原子性。

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();
      }
    }
}

• * 要是實現原子性操作，建議使用atomic類的系列對象：支持原子性操作（注意atomic類只保證本身方法的原子性，并不保證多次操作的原子性）

示例：
說明：

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();
      }
    }
}

看完了這篇文章，相信你對Java并發編程之volatile關鍵字的案例有了一定的了解，想了解更多相關知識，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！