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

一、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