Java并發(fā)編程之volatile關(guān)鍵字的案例

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

volatile-說明

• volatile關(guān)鍵字的作用是變量在多個線程可見；

• volatile 關(guān)鍵字是非原子性的

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

1. volatile :

• volatile關(guān)鍵字的作用是變量在多個線程可見；

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

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

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

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

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的值已經(jīng)被設(shè)置了false");
    }
}

2. volatile 關(guān)鍵字是非原子性的

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

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

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

import java.util.concurrent.atomic.AtomicInteger;
/**
* volatile關(guān)鍵字不具備synchronized關(guān)鍵字的原子性（同步）
* @@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();
      }
    }
}

• * 要是實現(xiàn)原子性操作，建議使用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在一個方法內(nèi)是非原子性的，需要加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并發(fā)編程之volatile關(guān)鍵字的案例有了一定的了解，想了解更多相關(guān)知識，歡迎關(guān)注億速云行業(yè)資訊頻道，感謝各位的閱讀！