并发编程（六）：线程安全性

  什么是线程安全的类？

  当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要额外同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的

  线程安全性包含哪些特性？

  原子性：提供了互斥访问，同一时刻只能有一个线程对它进行操作

  可见性：一个线程对主内存的修改可以及时被其他线程观察到

  有序性：一个线程观察其他线程的指令执行顺序，由于指令重排序的存在，该观察结果一般杂乱无序。

  原子性

  保证原子性的手段通常有以下几种

  当需要同步时，可能我们首先想到的就是synchronized，但是在竞争特别激烈时，synchronized可能并不是很好的选择，synchronized的使用方式大概有以下几种

  关于atomic，我们在前面的博客中已有实例应用，关于Lock的使用我们会在后面的博客中做专门的讲解，下面我们简单看一下synchronized的demo

  synchronized-demo1（修饰方法）

@Slf4j
public class SynchronizedExample1 {

    //修饰一个代码块
    public void test1(int j) {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                log.info("test1-{}-{}", j,i);
            }
        }
    }

    //修饰一个方法
    public synchronized void test2(int j) {
        for (int i = 0; i < 10; i++) {
            log.info("test2-{}-{}", j,i);
        }
    }

    public static void main(String[] args) {
        SynchronizedExample1 example1 = new SynchronizedExample1();
        SynchronizedExample1 example2 = new SynchronizedExample1();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(()->{
            example1.test2(1);
        });

        executorService.execute(()->{
            example2.test2(2);
        });

    }

}

  synchronized-demo2（修饰类）

@Slf4j
public class SynchronizedExample2 {

    //修饰一个类
    public static void test1(int j) {
        synchronized (SynchronizedExample2.class) {
            for (int i = 0; i < 10; i++) {
                log.info("test1-{}-{}", j,i);
            }
        }
    }

    //修饰一个静态方法
    public static synchronized void test2(int j) {
        for (int i = 0; i < 10; i++) {
            log.info("test2-{}-{}", j,i);
        }
    }

    public static void main(String[] args) {
        SynchronizedExample2 example1 = new SynchronizedExample2();
        SynchronizedExample2 example2 = new SynchronizedExample2();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(()->{
            example1.test1(1);
        });

        executorService.execute(()->{
            example2.test1(2);
        });

    }

}

  可见性

  导致共享变量在线程间不可见的原因

  通常我们有两种方式来保证可见性：

  a、synchronized

  java内存模型中关于synchronized有两条规定

  1、线程解锁前，必须把共享变量的最新值刷新到主内存

  2、线程加锁时将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（加锁与解锁必须是同一把锁）

  b、volatile

  volatile通过加入内存屏障和禁止重排序优化来实现可见性

  a、对volatile变量写操作时，会在写操作后加一条store屏障指令，将本地内存中的共享变量值刷新到主内存

  b、对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存读取共享变量

  volatile写：

  volatile读：

  有序性

  java内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性，有序性可依靠volatile、synchronized、Lock来保证。

  提起有序性，我们可以想到JMM（java内存模型）中一个非常重要的原则-happens-before原则：

  a、程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作

  b、锁定操作：一个unLock操作先行发生于后面对同一个锁的lock操作

  c、volatile变量规则：对一个变量的写操作先行发生于后面这个变量的读操作

  d、传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C

  e、线程启动规则：Thread对象的start（）方法先行发生于此线程的每一个动作

  f、线程中断规则：对线程interrupt（）方法的调用先行发生于被中断线程的代码检测到中断事件的发生

  g、线程终结规则：线程中所有操作都先行发生于线程的终止检测，可有通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行

  h、对象终结规则：一个对象的初始化完成先行发生于他的finalize（）（GC在回收对象之前调用该方法）方法的开始

  如果两个操作的执行次序，无法从happends-before原则推到出来，就不能保证有序性，虚拟机可随意的对他们进行重排序。