volatile是Java虚拟机提供的轻量级的同步机制。volatile关键字有如下两个作用,一句话概括就是内存可见性和禁止重排序。
1)保证被volatile修饰的共享变量对所有线程总是可见的,也就是当一个线程修改了一个被volatile修饰共享变量的值,新值总是可以被其他线程立即得知
2)禁止指令重排序优化。在执行程序时为了提高性能,编译器和处理器通常会重新安排指令的执行顺序。
 
  1. public class T {
  2. /*volatile*/ boolean running=true;
  3. void m(){
  4. System.out.println("m start");
  5. while (running){}
  6. System.out.println("m end");
  7. }
  8. public static void main(String[] args) {
  9. T t=new T();
  10. new Thread(()->t.m(),"t1").start();
  11. try {
  12. TimeUnit.SECONDS.sleep(1);
  13. } catch (InterruptedException e) {
  14. e.printStackTrace();
  15. }
  16. t.running=false;
  17. }
  18. }

这段代码中没加volatile的话,循环的后面的输出语句”m end”不会输出,但是main方法里面确实是已经将running的值改成了false。这里有关java的内存模型,简单来说就是程序运行时,running的值已经被加载到了缓存里面,而改的是t对象的running值在堆内存中。加了volatile就不一样了,它改完数值之后,会通知其他线程,让其他线程重新读一下堆内存中的值,也就是内存可见性。

 

  1. public class T1 {
  2. volatile int count=0;
  3. /*synchronized*/ void m(){
  4. for (int i=0;i<10000;i++){
  5. count++;
  6. }
  7. }
  8. public static void main(String[] args) {
  9. T1 t=new T1();
  10. List<Thread> threads=new ArrayList<Thread>();
  11. for(int i=0;i<10;i++){
  12. threads.add(new Thread(()->t.m(),"thread-"+i));
  13. }
  14. threads.forEach((o)->o.start());
  15. threads.forEach((o)->{
  16. try {
  17. o.join();
  18. } catch (InterruptedException e) {
  19. e.printStackTrace();
  20. }
  21. });
  22. System.out.println(t.count);
  23. }
  24. }

这段代码中,十个线程执行count++加到1w循环,理想状态当然是加到10w,但是volatile只能保持线程的可见性,不能保持原子性。给count变量加上了volatile,最后输出的count值也达不到10w。这就是volatile与synchronized的区别,volatile只能保持可见性,而synchronized可以保持可见性和原子性。但是volatile更加轻量级,能用volatile的情况下,尽量别用synchronized。

版权声明:本文为ruiyeclub原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/ruiyeclub/p/12296259.html