每天学习一点点211201--volatile关键字

轻量级同步机制：volatile关键字

1. volatile 的作用
   volatile 使变量在多个线程之间可见。
   volatile 与 synchronized 比较
   1. volatile 关键字是线程同步的轻量级实现，所以 volatile 性能肯定比 synchronized 要好；volatile 只能修饰变量，而 synchronized 可以修饰方法，代码块。随着 JDK 新版本的发布,synchronized 的执行效率也 有较大的提升,在开发中使用 sychronized 的比率还是很大的。（斜体字抄的，咱也不懂执行效率，咱也没怎么搞过多线程）。
   2. 多线程访问 volatile 变量不会发生阻塞，而 synchronized 可能会阻塞。
   3. volatile 能保证数据的可见性，但是不能保证原子性；而 synchronized 可以保证原子性，也可以保证可见性。
   4. volatile 解决的是变量在多个线程之间的可见性；synchronized 解决多个线程之间访问公共资源的同步性。

package com.jason.java.duoxiancheng.volatilekw;

/**
 * volatile 可以强制线程从公共内存中读取变量的值，而不是从工作内存中读取
 * @author Jason
 */
public class Test01 {
    public static void main(String[] args) {
        //创建 PrintString 对象
        PrintString printString = new PrintString();

        //开启子线程，让子线程执行 printString 对象的 printStringMethod() 方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                printString.printStringMethod();
            }
        }).start();

        //main 线程睡眠 1000 毫秒
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("在 main 线程中修改打印标志");
        printString.setContinuePrint(false);
        //程序运行，查看在 main 线程中修改了打印标志之后，子线程打印是否可以结束打印
        //程序运行后，可能会出现死循环情况
        //分析原因：main 线程修改了 printString 的打印表之后，子线程读不到
        //解决办法：使用 volatile 关键字修饰 printString 对象的打印标志
        //volatile 的作用可以强制从公共内存中读取变量的值，而不是从工作内存中读取

    }

    //定义类打印字符串
    static class PrintString{
        private volatile boolean continuePrint = true;

        public PrintString setContinuePrint(boolean continuePrint) {
            this.continuePrint = continuePrint;
            return this;
        }

        public void printStringMethod(){
            System.out.println(Thread.currentThread().getName() + "开始...");
            while (continuePrint) {
            }
            System.out.println(Thread.currentThread().getName() + "结束++++++++++++");
        }
    }
}

2. volatile 非原子特性
   volatile 关键字增加了实例变量在多个线程之间的可见性，但是不具备原子性。

package com.jason.java.duoxiancheng.volatilekw;

/**
 * @author Jason
 */
public class Tesst02 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new MyThread().start();
        }
    }

    static class MyThread extends Thread{
        //volatile 关键字仅仅是表示所有线程从主内存读取 count 变量的值
        //下面代码运行后不是线程安全的，想要线程安全，需要使用 synchronized 进行同步，如果使用
        //synchronized，也就不需要 volatile 了
        /*public volatile static int count;

        public static void addCount(){
            for (int i = 0; i < 1000; i++) {
                //count++ 不是原子操作
                count++;
            }
            System.out.println(Thread.currentThread().getName() + " count=" + count);
        }*/
        public static int count;
        public synchronized static void addCount(){
            for (int i = 0; i < 1000; i++) {
                count++;
            }
            System.out.println(Thread.currentThread().getName() + " count=" + count);
        }
        @Override
        public void run() {
            addCount();
        }
    }
}

3. 常用原子类进行自增自减操作
   除了使用 synchronized 进行同步外，也可以使用 AtomicInteger / AtomicLong 原子类进行实现。

package com.jason.java.duoxiancheng.volatilekw;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 使用原子类进行自增
 * @author Jason
 */
public class Test03 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new MyThread().start();
        }
        Thread.sleep(100);
        System.out.println(MyThread.count.get());
    }

    static class MyThread extends Thread{
        //使用 AtomicInteger 对象
        private static AtomicInteger count = new AtomicInteger();

        public static void addCount(){
            for (int i = 0; i < 1000; i++) {
                count.getAndIncrement();
            }
            System.out.println(Thread.currentThread().getName() + " count=" + count.get());
        }

        @Override
        public void run() {
            addCount();
        }
    }
}