Java?volatile關鍵字特性講解下篇

更新時間：2022年12月12日 16:22:13 作者：愛吃南瓜糕的北絡

JMM要求保證可見性、原子性、有序性，volatile可以保證其中的兩個，本篇文章具體驗證volatile的可見性，不原子性和禁重排，同時解決volatile的不保證原子性，讓代碼具有原子性

一、概述

關鍵字volatile雖然增加了實例變量在多個線程之間的可見性，但它卻不具備同步性，那么也就不具備原子性。

二、特性詳解

原子性是指一個線程的操作是不能被其他線程打斷的，同一時間只有一個線程對一個變量進行操作。在多線程情況下，每個線程的執(zhí)行結果不受其他線程的干擾，比如說多個線程同時對同一個共享成員變量n++ 100次，如果n的初始值為0，n最后的值應該是100，所以說多個線程是互不干擾的，這就是原子性的理解。但是實際n++b并不是原子性操作，n最后的值可能會不是100。

非原子性代碼演示：

@Test
public void test2() {
   DataDemo dataDemo = new DataDemo();
   for (int i=0; i<20; i++) {
       CountAddThread thread = new CountAddThread(dataDemo);
       thread.start();
   }
   while (Thread.activeCount() > 1) {
       Thread.yield();
   }
   System.out.println("number值增加了20000次，此時number的實際值為：" + dataDemo.getNumber());
}
public class DataDemo {
    volatile private int number = 0;
    public void add() {
        this.number = this.number + 10;
    }
    public int getNumber() {
        return number;
    }
    public void addOne() {
        this.number = this.number + 1;
    }
}
public class CountAddThread extends Thread {
    private DataDemo dataDemo;
    public CountAddThread(DataDemo dataDemo) {
        this.dataDemo = dataDemo;
    }
    @Override
    public void run() {
        for (int i=0; i<1000; i++) {
            dataDemo.addOne();
        }
    }
}

執(zhí)行結果：
number值增加了20000次，此時number的實際值為：19699

結果分析：

this.number = this.number + 1 并不是一個原子操作，也就是非線程安全的。this.number = this.number + 1 的操作步驟分解如下：

（1）從內存中取出number的值；

（2）計算number的值；

（3）將number的值寫到內存中；

假設在第2步計算值的時候，另外一個線程也修改i的值，那么這個時候就會出現(xiàn)臟數據。解決的辦法其實就是使用synchronized關鍵字。所以說volatile本省并不處理數據的原子性，而是強制對數據的讀寫及時影響到主內存的。

解決辦法：

（1）使用synchronized

可以通過對addOne方法添加synchronized關鍵字修飾，這樣每次只有1個線程能執(zhí)行addOne方法。

（2）使用JUC包下的AtomicInteger原子類進行實現(xiàn)。

原子操作是不能分割的整體，沒有其他線程能夠中斷或檢查正在原子操作中的變量。一個原子（atomic）類型就是一個原子操作可用的類型，它可以在沒有鎖的情況下做到線程安全。

使用synchronized 示例

@Test
public void test2() {
   DataDemo dataDemo = new DataDemo();
   for (int i=0; i<20; i++) {
        CountAddThread thread = new CountAddThread(dataDemo);
        thread.start();
   }
   while (Thread.activeCount() > 1) {
        Thread.yield();
   }
   System.out.println("number值增加了20000次，此時number的實際值為：" + dataDemo.getNumber());
}
public class CountAddThread extends Thread {
    private DataDemo dataDemo;
    public CountAddThread(DataDemo dataDemo) {
        this.dataDemo = dataDemo;
    }
    @Override
    public void run() {
        for (int i=0; i<1000; i++) {
            dataDemo.addOne();
        }
    }
}
public class DataDemo {
    volatile private int number = 0;
    public void add() {
        this.number = this.number + 10;
    }
    public int getNumber() {
        return number;
    }
    synchronized public void addOne() {
        this.number = this.number + 1;
    }
}

執(zhí)行結果：
number值增加了20000次，此時number的實際值為：20000

使用AtomicInteger原子類示例

@Test
public void test2() {
   DataDemo dataDemo = new DataDemo();
   for (int i=0; i<20; i++) {
       CountAddThread thread = new CountAddThread(dataDemo);
       thread.start();
   }
   while (dataDemo.getCount().get() != 20000) {
       Thread.yield();
   }
   System.out.println("count值增加了20000次，此時count的實際值為：" + dataDemo.getCount());
}
public class CountAddThread extends Thread {
    private DataDemo dataDemo;
    public CountAddThread(DataDemo dataDemo) {
        this.dataDemo = dataDemo;
    }
    @Override
    public void run() {
        for (int i=0; i<1000; i++) {
            dataDemo.atomicAddOne();
        }
    }
}
public class DataDemo {
    private AtomicInteger count = new AtomicInteger(0);
    public AtomicInteger getCount() {
        return count;
    }
    public void atomicAddOne() {
        count.getAndIncrement();
    }
}