Java并发多线程编程——Volatile原理与使用

优质文章,第一时间送达

76套java从入门到精通实战课程分享

一、volitile的理解

  • Volatile称之为轻量级锁,被volatile修饰的变量,在线程之间是可见的。

  • 可见即一个线程修改了这个变量的值,在另外一个线程中能够读到这个修改后的值。

  • Synchronized除了线程之间互斥以外,还有一个非常大的作用就是保证可见性。

  • 保证可见性的前提,多个线程拿到的是同一把锁,否则是保证不了的。

二、多个线程获取值案例(没有使用同步的情况)

1、代码

package com.xz.thread.t6;

/**
 * @description: 保证可见性的前提:多个线程拿到的是同一把锁,否则是保证不了的。
 *
 * @author: xz
 */
public class Demo {
    private int a=1;

public int getA() {
        return a;
    }

public void setA(int a) {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.a = a;
    }

public static void main(String[] args) {
        Demo d=new Demo();
        //第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                d.setA(10);
            }
        }).start();
        //第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(d.getA());
            }
        }).start();

try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println('最终的结果:'+d.getA());
    }
}

2、输出结果

3、结论

  • 在没有使用同步的情况下,同一个实例中多个线程获取的值是不相同的。

三、多个线程获取值案例(使用Volatile关键字的情况)

1、代码

package com.xz.thread.t6;

/** * @description: 保证可见性的前提:多个线程拿到的是同一把锁,否则是保证不了的。 * @author: xz */public class Demo2 {    public volatile int a = 1;

    public static void main(String[] args) {

        Demo2 d=new Demo2();        new Thread(new Runnable() {            @Override            public void run() {                d.a = 10;            }        }).start();

        new Thread(new Runnable() {            @Override            public void run() {                System.out.println(d.a);            }        }).start();

        try {            Thread.sleep(100);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println('最终的结果:'+d.a);    }}

2、输出结果

3、结论

  • 在使用Volatile关键字的情况下,同一个实例中多个线程获取的值是相同的。

四、多个线程获按顺序执行的案例

1、代码

package com.xz.thread.t6;

/**
 * @description:
 * @author: xz
 */
public class Demo3 {

public volatile Boolean run =false;

public static void main(String[] args) {
        Demo3 d3=new Demo3();

//第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println('第【'+i+'】次执行');
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                d3.run =true;//第一个线程执行完把run变量改成true
            }
        }).start();

//第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (!d3.run){
                    //当run !=true 时,不执行
                }
                System.out.println('线程2执行了===========');
            }
        }).start();
    }
}

2、输出结果

五、 Lock指令的理解

  • volatile可见性是通过汇编加上Lock前缀指令完成的。由此引出Lock指令的理解。

  • 在多处理器的系统上

  • 将当前处理器缓存行的内容写回到系统内存;

  • 这个写回到内存的操作会使在其他CPU里缓存了该内存地址的数据失效。

六、有Volatile为什么还使用synchronized

  • volatile关键字可以保证内存可见性和有序性,但不能保证原子性;

  • 也就是说synchronized可以取代Volatile,但是Volatile不能取代synchronized;

七、synchronized可以取代Volatile,为什么还用Volatile

  • Volatile称之为轻量级锁。

————————————————

版权声明:本文为CSDN博主「小志的博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。

(0)

相关推荐