前言

  在Android应用开发中，由于Android系统的单线程模型（UI主线程），使得一些耗时操作必须放在子线程执行；又由于线程间需要交互信息，在多线程环境中，需要做好同步操作，以防止不可预期的错误发生。因此，掌握多线程相关知识对于开发尤为重要。比如在我们常用的Okhttp，Rxjava等框架中都可以看见多线程的身影（ThreadPoolExecutor）

硬件概述

  由于计算机的存储设备（IO）与处理器（CPU）的运算能力之间有几个数量级的差距，所以现代计算机系统都不得不加入一层读写速度尽可能接近处理器运算速度的高速缓存（cache）来作为内存与处理器之间的缓冲：将运算需要使用到的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存之中没这样处理器就无需等待缓慢的内存读写了。
  基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但是引入了一个新的问题：缓存一致性（Cache Coherence）。在多处理器系统中，每个处理器都有自己的高速缓存，而他们又共享同一主存，如下图所示：多个处理器运算任务都涉及同一块主存，需要一种协议可以保障数据的一致性，这类协议有MSI、MESI、MOSI及Dragon Protocol等。Java虚拟机内存模型中定义的内存访问操作与硬件的缓存访问操作是具有可比性的，后续将介绍Java内存模型。
  除此之外，为了使得处理器内部的运算单元能竟可能被充分利用，处理器可能会对输入代码进行乱起执行（Out-Of-Order Execution）优化，处理器会在计算之后将对乱序执行的代码进行结果重组，保证结果准确性。与处理器的乱序执行优化类似，Java虚拟机的即时编译器中也有类似的指令重排序（Instruction Recorder）优化。

model_cache.png

Java内存模型

  Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。 Java内存模型中规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存（可以与前面将的处理器的高速缓存类比），线程的工作内存中保存了该线程使用到的变量到主内存副本拷贝，线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来完成，线程、主内存和工作内存的交互关系如下图所示：

java_thread.png

内存间交互操作

  关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：

·lock（锁定）：  作用于主内存的变量，把一个变量标识为一条线程独占状态。
·unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
·read（读取）：  作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
·load（载入）：  作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
·use（使用）：   作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
·assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
·store（存储）： 作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
·write（写入）： 作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

  如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。也就是read和load之间，store和write之间是可以插入其他指令的，如对主内存中的变量a、b进行访问时，可能的顺序是read a，read b，load b， load a。Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

·不允许read和load、store和write操作之一单独出现
·不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
·不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
·一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
·一个变量在同一时刻只允许一条线程对其进行lock操作，lock和unlock必须成对出现
·如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
·如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
·对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

指令重排序

  在执行程序时为了提高性能，编译器和处理器经常会对指令进行重排序。重排序分成三种类型：

·编译器优化的重排序。编译器在不改变单线程程序语义放入前提下，可以重新安排语句的执行顺序。
·指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
·内存系统的重排序。由于处理器使用缓存和读写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

同步关键字

Java提供了volatile和synchronized来保证同步

volatile

禁止指令重排序，保证内存可见性，但不保证原子性。仅作用于变量。

synchronized

禁止指令重排序，保证内存可见性，保证原子性。作用于方法，代码块。

原子性

由Java内存模型来直接保证的原子性变量包括read,load,assign,use,store,write,我们大致可以认为基本数据类型的访问读写是具备原子性的(long，double除外)

可见性

可见性是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。volatile就是这个作用。
除了vloatile外，Java还有synchronized和final能保证可见性。同步块的可见性是由"对一个变量执行unlock操作之前，必须先把次变量同步回主内存中"这条规则获得的，而final的可见性是指：被final修饰的字段在构造其中一旦初始化完成，并且构造器没有把this的引用传递出去（this引用逃逸是一件很危险的事，其他线程有可能通过这个引用访问到“初始化了一半”的对象），那在其他线程中就能看见final的值。

有序性

如果在本线程内观察，所有的操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无需的。前半句是指“线程内表现为串行的语义”，后半句是指“指令重排序”现象和“工作内存与主内存同步延迟”现象。

Java线程的实现

线程是比进程更轻量级的调度执行单位，线程的引入，可以把一个进程的资源分配和执行调度分开，各个线程即可以共享进程资源（内存地址、文件I/O等），又可以独立调度(线程是CPU调度的基本单位)。
实现线程主要有3中方式：使用内核线程实现、使用用户线程实现和使用用户线程加轻量级进程混合实现。

内核线程

一对一线程模型 ，内核线程(Kernel-Level Thread,KLT)是直接有操作系统内核支持的线程，这种线程由内核来完成线程切换，内核通过操作调度器(Scheduler)对线程进行调度，并负责将线程的任务映射带各个处理器上。
程序一般不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进程（Light Weight Process,LWP），轻量级进程就是我们通常意义上所讲的线程，由于每个轻量级进程都由一个内核线程支持，因此只有先支持内核线程，才能有轻量级进程。这种轻量级进程与内核线程间1:1的关系称为一对一的线程模型，如下图所示：

kernel_thread.png

用户线程

一对N线程模型 ，用户程序完全模拟线程的行为，编码时操作的线程是用户程序模拟的线程，操作系统内核不能感知你做了创建、调度等等线程操作。许多编程语言最初使用过这种方式，但现在基本放弃了这种。

userthread.png

用户线程加轻量级进程混合实现

N对M线程模型 ，也有很多语言使用混合实现。

hybrid.png

线程调度

线程调度是指系统为线程分配处理器使用权的过程，主要的调度方式有两种：

协同式线程调度（Cooperative Threads-Scheduling）

这种方式是原始方式，由一个线程执行完通知另一个线程。已经很少使用，很容易造成阻塞。

抢占式线程调度（Preemptive Threads-Scheduling）

主流方式，由系统来根据一系列复杂的规则为每个线程分配执行时间，线程的切换不是由线程自己做主（Java可以有Thread.yield()来让出执行时间，但是没有获取执行时间的方式）。
Java语言一共设置了10个优先级（Thread.MIN_PRIORITY到Thread.MAX_PRIORITY，1-10，正常值是5）;在两个线程同时处于ready状态时，优先级越高的线程越容易被烯烃选择执行。
但是不要依赖优先级，因为它并不靠谱，最终结果仍取决于OS。比如Java有10种优先级，而linux优先级从-20-19，那怎么对应呢；比如windows有7中优先级。

状态切换

Java语言定义了5中线程状态，在任意一个时间点，一个线程只能有且只有一种状态，这5种状态如下：

·新建(New): 创建后，尚未启动的线程
·运行(Runnable): 包括了操作系统状态的Running和Ready，即此时线程可能运行，也可能CPU正在为它分配时间片，还没运行。
·无限期等待(Waiting)：处于这种状态的线程不会被分配CPU执行时间，它们要等其他线程显示的唤醒。调用如下方法会时当前线程进入Waiting状态：
        没有设置timeout的java.lang.Object#wait();
        没有设置timeout的threadObj.join()/threadObj.join(0)方法
        LockSupport.park()方法
·限期等待：同上，只是设置了timeout，在时间到了后自动唤醒
        java.lang.Object#wait(long);
        java.lang.Thread#sleep(long);
        threadObj.join(n)方法
        LockSupport.parkNanos(obj ,n)方法
        LockSupport.parkUntil(obj ,n)方法
·阻塞(Blocked)：线程被阻塞了，阻塞与等待的区别是：阻塞状态在等待一个排它锁，这个时间在另外一个线程放弃这个所的时候发生；而等待则是等待一段时间，或者被唤醒。
·结束(Terminated)：已终止的线程状态，线程已结束执行。

state.png

参考：深入理解Java虚拟机，作者：周志明，侵删。