volatile实现可见性但不保证原子性

   volatile关键字:

  • 能够保证volatile变量的可见性
  • 不能保证volatile变量复合操作的原子性

         volatile如何实现内存可见性:

         深入来说:通过加入内存屏障和禁止重排序优化来实现的。

  • 对volatile变量执行写操作时,会在写操作后加入一条store屏障指令
  • 对volatile变量执行读操作时,会在读操作前加入一条load屏障指令

         通俗地讲:volatile变量在每次被线程访问时,都强迫从主内存中重读该变量的值,而当该变量发生变化时,又会强迫线程将最新的值刷新到主内存。这样任何时刻,不同的线程总能看到该变量的最新值。

         线程写volatile变量的过程:

  • 改变线程工作内存中volatile变量副本的值
  • 将改变后的副本的值从工作内存刷新到主内存

         线程读volatile变量的过程:

  • 从主内存中读取volatile变量的最新值到线程的工作内存中
  • 从工作内存中读取volatile变量的副本

         volatile不能保证volatile变量复合操作的原子性:

private int number = 0;  
number++; //不是原子操作  

它分为三步:
         读取number的值
         将number的值加1
         写入最新的number的值

          保证number自增操作的原子性:

  • 使用synchronized关键字
  • 使用ReentrantLock
  • 使用AtomicInteger

          使用synchronized关键字

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
/** 
 * @author InJavaWeTrust 
 */  
public class TestSyn implements Runnable {  
  
    private int number = 0;  
  
    public int getNumber() {  
        return this.number;  
    }  
  
    public void run() {  
        increase();  
    }  
  
    public void increase() {  
        synchronized (this) {  
            this.number++;  
        }  
    }  
  
    public static void main(String[] args) {  
        ExecutorService exec = Executors.newFixedThreadPool(1000);  
        TestSyn syn = new TestSyn();  
        for (int i = 0; i < 1000; i++) {  
            exec.submit(syn);  
        }  
        System.out.println("number : " + syn.getNumber());  
        exec.shutdown();  
    }  
}  

 使用ReentrantLock

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
/** 
 * @author InJavaWeTrust 
 */  
public class TestRee implements Runnable {  
  
    private Lock lock = new ReentrantLock();  
    private int number = 0;  
  
    public int getNumber() {  
        return this.number;  
    }  
  
    public void run() {  
        increase();  
    }  
  
    public void increase() {  
        lock.lock();  
        try {  
            this.number++;  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    public static void main(String[] args) {  
        TestRee ree = new TestRee();  
        ExecutorService exec = Executors.newFixedThreadPool(1000);  
        for (int i = 0; i < 1000; i++) {  
            exec.submit(ree);  
        }  
        System.out.println("number : " + ree.getNumber());  
        exec.shutdown();  
    }  
}  

 使用AtomicInteger

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.atomic.AtomicInteger;  
  
/** 
 * @author InJavaWeTrust 
 */  
public class TestAtomic implements Runnable {  
  
    private static AtomicInteger number = new AtomicInteger(0);  
  
    public void run() {  
        increase();  
    }  
  
    public void increase() {  
        number.getAndAdd(1);  
    }  
  
    public static void main(String[] args) {  
        TestAtomic ato = new TestAtomic();  
        ExecutorService exec = Executors.newFixedThreadPool(1000);  
        for (int i = 0; i < 1000; i++) {  
            exec.submit(ato);  
        }  
        System.out.println("number : " + number.get());  
        exec.shutdown();  
    }  
}

评论

h
hw_7864

⭐️ Admin快速开发: https://show.cool-admin.com/

赞 0
h
hw_7864

⭐️ 官方文档: https://cool-js.com

赞 0
h
hw_7864

⭐️ chatgpt在线体验: https://cool-js.com/ai/chat-vip/index.html?r=helloworld

赞 0