volatile用法

volatile修饰变量用于多线程保证可见性及有序性，不保证原子性

参考：Java并发编程：volatile关键字解析 - Matrix海子 - 博客园

import java.util.concurrent.atomic.AtomicInteger;

public class ValotileTest {

//    static int i = 0;
//    volatile static User user = new User("zhangsan", 18, true);
    static User user = new User("zhangsan", 18, true);

//    static AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) {
        new Thread(()->{
            System.out.println("执行中。。。");
//            while(i == 0){
//
//            }
            while(user.isBoy()){

            }
//            while(atomicInteger.get() == 0){
//
//            }
            System.out.println("执行结束");
        }).start();

        new Thread(()->{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//            i = 1;
            user.setBoy(false);
//            atomicInteger.incrementAndGet();
            System.out.println("线程一执行结束");
        }).start();

    }

}

class User{

    public User(String name ,int age, boolean isBoy){
        this.name = name;
        this.age = age;
        this.isBoy = isBoy;
    }

    private String name;
    private int age;
    volatile private boolean isBoy;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setBoy(boolean boy) {
        isBoy = boy;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public boolean isBoy() {
        return isBoy;
    }
}

可见性：由于cpu高速缓存，多线程之间修改共享变量不能保证可见性，在变量前加volatile即可保证可见性，普通变量或引用变量前加volatile都可保证可见性，引用对象内的内部变量前加volatile也可保证可见性。

有序性：volatile能保证有序性_这瓜保熟么的博客-CSDN博客_volatile有序性

修饰范围：volatile关键字可以修饰在类变量或者实例变量上，不能修饰在方法参数，局部变量，实例常量以及类常量上。