并发编程核心——五.线程安全与数据同步

五、线程安全与数据同步

本章我们将学习多线程中最复杂也是最重要的内容之一，那就是数据同步、线程安全、 锁等概念，在串行化的任务执行过程中，由于不存在资源的共享，线程安全的问题几乎不用 考虑，但是串行化的程序，运行效率低下，不能最大化地利用 CPU 的计算能力，随着 CPU 核数的增加和计算速度的提升，串行化的任务执行显然是对资源的极大浪费，比如 B 客户提 交了一个业务请求，只有等到 A 客户处理结束才能开始，这样的体验显然是用户无法忍受的。

无论是互联网系统，还是企业级系统，在追求稳定计算的同时也在追求更高的系统吞吐 量，这也对系统的开发者提出了更高的要求，如何开发高效率的程序成了每个程序员必须掌 握的技能，并发或者并行的程序并不意味着可以满足越多的 Thread, Thread 的多少对系 统的性能来讲是一个抛物线，同时多线程的引入也带来了共享资源安全的隐患。在本章中， 我们主要来探讨如何在安全的前提下高效地共享数据

什么是共享资源？共享资源指的是多个线程同时对同一份资源进行访问（读写操作）， 被多个线程访问的资源就称为共享资源，如何保证多个线程访问到的数据是一致的，则被称 为数据同步或者资源同步。

5.1、数据同步

5.1.1、数据不一致问题的引入

在第 2 章中，我们写了一个简单的营业大厅叫号机程序，当时我们设定的最大号码是 50(可能有些人已经测试出了问题），现在我们对该程序稍加修改，就会出现数据不一致的 情况，具体如下：

package com.bjsxt.chapter02.demo06;

import java.util.concurrent.TimeUnit;

public class CounterWindowRunnable implements Runnable {
   
    // 最多受理 50 笔业务
    private static final int MAX = 500;// 元数据区域
    //
    private int index = 1;// 堆

    @Override
    public void run() {
   
        while(index <= MAX){
   // 1.get index, 2.get MAX , 3.compare true
            try{
   
                TimeUnit.MILLISECONDS.sleep(1);
            }catch (InterruptedException e){
   
                e.printStackTrace();
            }

            // 1.get index , get name 2.输出
            System.out.printf("请【%d】号到【%s】办理业务\n",index++,Thread.currentThread().getName());
            // 1.get index ,2. +1, 3. put index
            //index = index + 1;
        }
    }

    public static void main(String[] args) {
   
        // 堆
        final CounterWindowRunnable task = new CounterWindowRunnable();
        new Thread(task,"一号窗口").start();
        new Thread(task,"二号窗口").start();
    }
}

多次运行上述程序，每次都会有不一样的发现，但是总结起来主要有三个问题，具体如 下。
第一，某个号码被略过没有出现。 
第二，某个号码被多次显示。 
第三，号码超过了最大值 50。
多次运行上面的程序，找出了数据不一致的几种情况，如下图所示。

5.1.2、数据不一致问题原因分析
假设有一个CPU，两个线程Thread-1,Thread-2，共享资源 index=0。
线程执行内容：

public void run() {
   
    while(index <= MAX){
   // 1.get index,get MAX 2. compare
        try{
   
            TimeUnit.MILLISECONDS.sleep(1);// 3. 当前运行线程RUNNIG进入TIMED_WATING
        }catch (InterruptedException e){
   
            e.printStackTrace();
        }
        System.out.printf("请【%d】号到【%s】办理业务\n",index++,Thread.currentThread().getName());// 4. get index 5.输出 6.get index 7.index + 1 8. put (index + 1)
    }
}

1.get index,get MAX
2. compare
3. 当前运行线程RUNNIG进入TIMED_WATING
4. get index
5. 输出
6. get index
7. index + 1
8. put (index + 1)

A. 号码被略过

如图所示，线程的执行是由 CPU 时间片轮询调度的，假设此时线程 1 和 2 都执行 到了 index=65 的位置，其中线程 2 将 index 修改为 66 之后未输出之前，CPU 调度器将 执行权利交给了线程 1,线程 1 直接将其累加到了 67,那么 66 就被忽略了。

B. 重复数字

线程 1 执行 index+1,然后 CPU 执行权落入线程 2 手里，由于线程 1 并没有给 index 赋予计算后的结果 393,因此线程 2 执行 index+1 的结果仍然是 393,所以会出现重复号码 的情况。

C.超出范围的数字
我的理解是如果是一个cpu情况下，要并发，这两个线程的各自的程序计数器只保存下一步代码，导致数据不一致。看见java代码要想到cpu微指令，拆分为取数据，操作数据，放回数据。一般保证只让一个线程操作地方就是这个。

下面来分析一下号码超过最大值的情况，当 index=499 的时候，线程 1 和线程 2 都看 到条件满足，线程 2 短暂停顿，线程 1 将 index 增加到了 500,线程 2 恢复运行后又将 500 增加到了 501,此时就出现了超过最大值的情况。 我们虽然使用了时序图的方式对数据同步问题进行了分析，但是这样的解释还是不够 严谨，后面我们会讲解 Java 的内存模型以及 CPU 缓存等知识，到时候会更加清晰和深入的 讲解数据不一致的问题。

5.2、初识 synchronized 关键字

5.1.1 节出现的几个问题，究其原因就是因为多个线程对 index 变量（共享变量/资源 同时操作引起的，在 JDK1.5 版本以前，要解决这个问题需要使用 synchronized 关键字， synchronized 提供了一种排他机制，也就是在同一时间只能有一个线程执行某些操作，在 本章中，我们就来详细地探讨一下 synchronized 关键字的本质和用法。

5.2.1、什么是 synchronized？

下面是一段来自于 JDK 官网对 synchronized 关键字比较权威的解释，如图所示。

上述解释的意思是： synchronized 关键字可以实现一个简单的策略来防止线程干扰 和内存一致性错误，如果一个对象对多个线程是可见的，那么对该对象的所有读或者写都将 通过同步的方式来进行，具体表现如下。 
synchronized 关键字提供了一种锁的机制，能够确保共享变量的互斥访问，从而防止 数据不一致问题的出现。 
synchronized 关键字包括 monitor enter 和 monitor exit 两个 JVM 指令，它能 够保证在任何时候任何线程执行到 monitor enter 成功之前都必须从主内存中获取数 据，而不是从缓存中，在 monitor exit 运行成功之后，共享变量被更新后的值必须 刷入主内存（后面会重点介绍） 
synchronized 的指令严格遵守 java happens-before 规则，一个 monitor exit 指 令之前必定要有一个 monitor enter（后面会详细介绍）

5.3、synchronized 关键字的用法

synchronized 可以用于对代码块或方法进行修饰，而不能够用于对 class 以及变量 进行修饰。

5.3.1、同步方法

同步方法的语法非常简单即： [default|public|private|protected] synchronized [static] type method()
示例代码如下：

5.3.2、同步代码块

介绍了什么是 synchronized 关键字以及它的基本用法之后，我们再次改写一下叫号 程序：

package com.bjsxt.chapter05.demo01;

import java.util.concurrent.TimeUnit;

public class CounterWindowRunnable implements Runnable {
   
    // 最多受理 50 笔业务
    private static final int MAX = 500;// 元数据区域
    //
    private int index = 1;// 堆

    private static final Object MONITOR = new Object();
    @Override
    public void run() {
   
        synchronized (MONITOR){
   
            while(index <= MAX){
   
                try{
   
                    TimeUnit.MILLISECONDS.sleep(1);
                }catch (InterruptedException e){
   
                    e.printStackTrace();
                }

                // 1.get index , get name 2.输出
                System.out.printf("请【%d】号到【%s】办理业务\n",index++,Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
   
        // 堆
        final CounterWindowRunnable task = new CounterWindowRunnable();
        new Thread(task,"一号窗口").start();
        new Thread(task,"二号窗口").start();
    }
}

运行结果：全都是1好窗口。但是对于共享变量index已经没有跳号、重复号、超出最大范围的错误。数据是正确的。
上面的程序无论运行多少次，都不会出现数据不一致的问题。