《Java虚拟机》之内存模型与线程（下）深入理解jvm

在编程学习中，并发是我们躲不开的一个话题。在Java语言里的并发，大多数都与线程离不开。我们将探讨在Java虚拟机里面线程是如何实现的。
二.Java与线程当说起进程时，我们第一想起的就是多线程。在开始分析之前，我们有必要明确何为进程，何为线程。我们知道，一个良好的定义和理解是对系统学习的一大助力。在百度百科中的对线程和进程的定义是这样的：
线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程
进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
我们知道，线程是比进程更加轻量级的调度单位。线程的引入，可以把一个进程的资源分配和执行调度分开，各个线程既可以共享进程的资源（内存地址，文件I/O等），又可以独立调度。事实上，线程是CPU调度的基本单位。
更加通俗的讲，进程是执行中的一段程序，即一旦程序被载入到内存并准备执行时，它就是一个进程。进程是表示资源分配的基本单位，又是调度运行的基本单位，是系统中的并发执行的单位。而单个进程中执行中的每一个任务都是一个线程，线程是进程中执行的最小单位。而且，一个线程只能属于一个进程，一个进程可以有多个线程。采用类比的方式来说，其间的关系好像高速公路网络。我们可以把高速路上行驶的汽车比作为计算机系统内的资源，把一条宽敞的马路比作是进程，又把路上的每一个车道比作是线程。狭义的来讲，马路上都有几条互不干扰的车道，车道上行驶的车辆就是一个个系统调度和执行的资源。一条车道必然只属于这一条马路，而这马路可以有多个车道，只有在存在车道的基础下，才会构成马路。当然了，也可以像是乡村马路，一个车道就是一条马路，构造单线程。所谓的，多进程不就像是有多辆汽车在同一条马路上的不同车道上并驾齐驱嘛。
2.1线程的实现
在Java里面，实现线程的主要有3种方法：

使用内核线程实现：

内核线程（Kernel-Level Thread,KLT）就是直接由操作系统内核（Kernel）支持的线程。这种线程由内核来完成线程的切换，内核通过操纵调度器（Scheduler）对线程进行调度，并赋值将线程的任务映射到各个处理器上。每个内核线程可以视为内核的一个分身，这样操作系统就有能力同时处理多件事情，支持多线程的内核就叫做多线程内核。
2.使用用户线程实现
从广义上讲，一个线程只要不是内核线程，它就可以被认为是用户线程。从这个定义来看，轻量级进程也是属于用户线程（轻量级进程就是我们通常意义上所讲的线程，由于每个轻量级进程都由一个内核线程支持，因此只有先支持内核线程，才能有轻量级进程）。狭义上的用户线程是指完全建立在用户空间的线程库上，系统内核不能感知线程存在的实现，用户线程的创建，同步，销毁，调度完全在用户态中完成，不需要内核的帮助。
3.使用用户线程加轻量级进程混合实现
即将内核线程与用户线程一起使用。在这种模式下，即存在用户线程，又存在轻量级进程。
2.2Java线程调度
线程调度是指系统为线程分配处理器使用权限的过程。主要的调度方式有两种：

协同式线程调度：

使用协同式调度的多线程系统，线程的执行时间由线程本身来控制，线程把自己的工作执行完成后，要自动通知系统切换到另一个线程上。协同式多线程的最大好处是实现简单，而且由于线程要把自己的任务完成过后才会进行线程切换，切换线程对于线程自己是可见的，不存在线程同步问题。当然其坏处也很明显，线程控制时间不可控制，很有可能造成阻塞。所以现在不推荐使用协同式。

2. 抢占式线程调度

使用抢占式调度的多线程系统，那么每个线程将会有系统来分配执行时间，线程的切换不再有线程本身来决定了。现在Java使用的线程调度方法就是抢占式调度，当一个进程出现了问题，可以使用任务管理器把这个进程“杀掉”，来保证系统的稳定。

针对Java线程调度是由系统自动完成的，当某些情况下，我们需要为某线程多一些执行时间，某些线程少一点时间时，推出了一项称为设置线程优先级的操作来实现。在Java语言里，一共设置了10个级别的线程优先级（1->10,Min-》Max）。当两个线程同时处于ready状态时，优先级越高的越容易被系统选择执行。但是这个优先级并不太靠谱，原因是Java的线程是通过映射到系统的原生线程上来实现的，线程的调度最终还是要取决于操作系统。
2.3状态转换
Java语言里定义了5中线程状态，在任意一个时间点，一个线程也只能是有且只有一种状态：

新建（new）:创建后尚未启动的线程处于这个状态
运行（runnable）：Runnable包括了操作系统线程状态中的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。
无限期等待（waiting）：处于这种状态的线程不会被CPU分配执行时间，它们要等待被其他的线程显示地唤醒。以下方法会将线程陷入到无限期的等待状态：

没有设置Timeout参数的Object.wait()方法
没有设置Timeout参数的Thread.join()方法
LockSupport.park()方法

4.限期等待（Timed Waiting）:处于这种状态的线程也不会被CPU分配执行时间，不过无须等待被其他的线程显示的唤醒，在一定的时间后它们会被系统自动唤醒。以下方法会使线程陷入到期限等待状态：

Thread.sleep()方法
设置了Timeout参数的Object.wait()方法
设置了Timeout参数的Thread.join()方法
LockSupport.parkNanos()方法
LockSupport.parkUntil()方法

5.阻塞（Blocked）:线程被阻塞了，“阻塞状态”与“等待状态”的区别是：阻塞状态在等待着获取到一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生；而等待状态则是在等待一段时间后，或者是唤醒动作的发生。在程序等待进入同步区域时，线程将进入这种状态。
6.结束（Terminated）:已终止线程的线程状态，线程已经结束执行。
2.4线程安全
首先，什么是线程安全，百度定义：多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
线程安全问题大多是由全局变量及静态变量引起的，局部变量逃逸也可能导致线程安全问题。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
位流更加深入的理解线程安全，在这里我们可以将各种操作共享的数据分为5类，其线程安全的“安全程度”由强到弱：不可变，绝对线程安全，相对线程安全，线程兼容和线程对立。

不可变：不可变（Immutable）的对象一定是线程安全的，无论是对象的方法实现或者是方法的调用者，都不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确的构建出来（没有发生this引用逃逸的情况），那其外部的可见状态永远就不会改变。参考被final关键字修饰的基本数据类型，以及java.lang.String类的对象，它是一个典型的不可变对象，无论是调用它的substring()方法，replace（）方法，concat()方法都不会影响其原先的值，只会返回一个新构造的字符串对象。
绝对线程安全：不管运行环境如何，调用者都不需要任何额外的同步措施。如果说java.util.Vector是一个线程安全的容器，大家都会认同，因为它的add(),get(),size()方法都是被synchronized修饰的。但是它在某些情况下，任然需要添加同步手段。
相对线程安全：就是我们通常所讲的线程安全它需要保证对这个对象单独操作是线程安全的，我们在调用时不需要做额外的保障措施。但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。大部分的线程安全类都属于这种类型，例如Vector,HashTable,Collections的synchronizedCollection()方法包装的集合等。
线程兼容：指对象本身并不是线程安全的，但可以通过在调用端正确的使用同步手段来保证对象在并发环境中可以安全的使用。Java API中大部分的类都是属于线程兼容的，如ArrayList和HashMap等。
线程对立：无论是否采取了同步措施，都无法再多线程环境中并发的使用。

2.5线程安全的实现方法
1.互斥同步
互斥同步（Mutual Exclusion&Synchronized）是一种常见的并发正确性保证手段。同步是指再多个线程并发访问共享数据时，保证共享数据在同一时刻只能被一个（或者是一些，使用信号量的时候）线程使用。而互斥是实现同步的一种手段，临界区（Critical Section），互斥量（Mutex）和信号量（Semaphore）都是主要的互斥实现方式。因此，互斥是因，同步是果；互斥是方法，同步是目的。
在Java中，最常见的互斥同步手段就是添加synchronized关键字。synchronized在经过编译后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令。这两个字节码指令都需要一个reference（引用）类型的参数来指明要锁定和解锁的对象。如果Java程序中的synchronized明确指定了对象的参数，那就是这个对象的reference；如果没有明确指定，那就根据synchronized修饰的是实例方法还是类方法，去取对应的对象实例或者是Class对象来作为锁对象。
根据虚拟机规范，在执行monitorenter指令，首先要尝试获取对象的锁。如果这个对象没被锁定，或者是当前线程已经有了那个对象的锁，把锁的计数器加1，相应的，在执行monitorexit指令时将会把计数器值减1；当计数器的值为0时，锁就被释放掉。如果获取对象的锁失败，那么当前线程就要阻塞等待，直到对象锁被另一个线程释放为止。在这里有两点需要特别注意，首先，synchronized同步块对同一个线程来说是可重入的，不会出现把自己锁死的问题。其次是，同步块在已进入的线程执行结束之前，会阻塞后面其他的线程进入。
除开synchronized关键字外，还可以使用java.util.concurrent(J.U.C)包中的ReentrantLock(重入锁)来实现同步。与synchronized相似，它们都具备一样的线程重入特性，相较之下，ReentrantLock增加了一些高级特性：等待可中断，可实现公平锁，以及锁可以绑定多个条件

等待可中断是指当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他的事情。
公平锁是指多个线程在等待同一个锁时。必须按照申请锁的时间顺序来依次获得；而非公平锁则不保证这一点，在锁释放时，任何一个等待锁的线程都有机会获得锁。synchronized中的锁是非公平的，ReentrantLock默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
锁绑定多个条件是指一个ReentrantLock对象可以同时绑定多个Condition对象，而在synchronized中，锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含的条件，如果要和多于一个的条件相关联时，就不得不额外添加一个锁；而ReentrantLock则无需这样，只要多次调用newCondition()方法即可。

2.非阻塞同步
互斥同步最主要的问题是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。从处理方式上说，互斥同步是一种悲观的并发策略，总认为只要不去做正确的同步措施，那就一定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁。相对的，有乐观策略，通俗地说，就是先进行操作，如果没有其他的线程竞争共享数据，那操作就成功了，否则，就再采取措施。这种乐观的并发策略的许多实现不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Sychronization）。为了实现乐观策略，需要“硬件指令集的发展”，硬件保证一个从语义上看起需要多次操作的行为只需要通过一条处理器指令就可以完成了，这类常用指令有：

测试并设置（Test-and-Set）
获取并增加（Fetch-and-Increment）
交换（Swap）
比较并交换（Compare-and-Swap，CAS）
加载链接/条件存储（Load-Linked/Store-Conditional，LT/SC）

CAS(Compare-and-Swap,比较并交换)指令需要3个操作数，分别是内存位置V,旧的预期值A和新值B。CAS指令执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则它就不执行更新，但是无论是否更新了V的值，都会返回V的旧值，这个过程是一个原子操作。
【《Java虚拟机》之内存模型与线程（下）】>参考《深入理解Java虚拟机》
>争渡争渡，惊起一滩欧鹭。
==欲知后事如何，请见下回分解==