1. 线程的实现
实现线程主要有以下三种方式：
使用内核线程实现 ：内核线程（Kernel Thread， KLT）就是直接由操作系统内核（Kernel，下称内核）支持的线程，这种线程由内核来完成线程切换，内核通过操纵调度器（Scheduler）对线程进行调度，并负责将线程的任务映射到各个处理器上。相对而言程序一般不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进程（Light Weight Process， LWP），轻量级进程就是我们通常意义上所讲的线程，由于每个轻量级进程都由一个内核线程支持，因此只有先支持内核线程，才能有轻量级进程。这种轻量级进程与内核线程之间1：1的关系称为一对一的线程模型。由于是轻量级进程基于内核线程实现的，所以各种进程操作，如创建/析构及同步，都需要进行系统调用。而系统调用的代价相对较高，需要在用户态（User Mode）和内核态（Kernel Mode）中来回切换；每个轻量级进程都需要有一个内核线程的支持，因此轻量级进程需要消耗一定的内核资源（如内核线程的栈空间），因此一个系统支持轻量级进程是有限的。
使用用户线程实现：指的是完全建立在用户空间的线程库上，系统内核不能感知到线程存在的实现。用户线程的建立/同步/销毁和调度完全在用户态完成，不需要内核的帮助。如果程序实现得当，这种线程不需要切换到内核态，因此操作快速且低消耗，也可以支持规模更大的线程数量，部分高性能数据库中的多线程就是由用户线程实现的。这种进程与用户线程之间1：N的关系称为一对多的线程模型。使用用户线程的优势在于不需要系统内核的支援，劣势也在于没有系统内核的支援，所有的线程操作都需要用户程序自己处理。
-
使用用户线程加轻量级进程混合实现：既存在用户线程，也存在轻量级进程。
java虚拟机的线程是怎样实现的很多程度取决于操作系统支持怎样的线程模型。
2. Java线程调度
线程调度是指系统为线程分配处理器使用权的过程。主要分为两种调度方式：
协同式线程调度（Cooperative Threads -Scheduling） ：线程的执行时间由线程本身来控制，线程完成自己的工作后，主动通知系统切换到另外一个线程上。优势在于实现简单，不用考虑线程同步问题；但同时线程的执行时间不可控制，如果线程编写存在问题，那么程序就会一直处于阻塞状态。
抢占式线程调度（Preemptive Threads -Scheduling） ：线程的执行时间由系统来分配。优势在于线程的执行时间是可控的，不会出现由于一个线程而导致整个进程阻塞的现象。但实现比较复杂，要解决线程之间的同步问题。
3. 线程状态的转换
Java语言定义了5种线程状态 ，在任意时间点，一个线程只能有且只有其中的一种状态。
- 新建 （New）： 创建后尚未启动的线程处于这种状态。
- 运行 （Runable）： Runable包括了系统线程状态中的Running和Ready，也就是说处于此状态的线程有可能正在执行也有可能在等待系统分配资源。
-
无限期等待（Waiting）： 处于这种状态的线程不会被分配CPU执行时间，它们要等待其他线程显示地唤醒。以下方法会让线程陷入无限期的等待状态：
1）没有设置Timeout参数的Object.wait()方法。
2）没有设置Timeout参数的Thread.join()方法。
3）LockSupport.park()方法。 -
限期等待（Timed Waiting）： 处于这种状态的线程也不会被分配CPU执行时间，不过无须等待被其他线程显示地唤醒，在一定时间后由系统自动唤醒。以下方法会让线程陷入限期的等待状态：
1）Thread.sleep()方法。
2）设置了Timeout参数的Object.wait()方法。
3）设置了Timeout参数的Thread.join()方法。
4）LockSupport.parkNanos()方法。
5）LockSupport.parkUntil()方法。
4. 线程安全
《Java Concurrency In Practice》一书中对于线程安全有一个比较恰当的定义：“当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的。
Java语言中各种操作共享的数据分为以下5类：
不可变 ：在java语言中，不可变的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施，"不可变"带来的安全性是最简单和最纯粹的。如果共享数据是一个基本数据类型，那么只要在定义时使用final关键字修饰它就可以保证它是不可变的；如果共享数据是一个对象，那就需要保证对象的行为不会对其状态产生任何影响才行，可以参考java.lang.String类的对象，它是一个典型的不可变对象，我们调用它的subString(),replace()和concat()这些方法都不会影响它原来的值，只会返回一个新构造的字符串对象。
绝对线程安全 ：绝对的线程安全完全满足线程安全的定义，在Java API中标注自己是线程安全的类，大多数都不是绝对的线程安全。以下一段代码为对Vector线程安全的测试：
public class VectorSafeTest {
private static Vector<Integer> vector = new Vector<>();
public static void main(String[] args) {
while (true){
for (int i = 0 ; i < 10 ; i++){
vector.add(i);
}
Thread removeThread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0 ; i<vector.size(); i++){
vector.remove(i);
}
}
});
Thread printThread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0 ; i<vector.size(); i++){
System.out.println(vector.get(i));
}
}
});
removeThread.start();
printThread.start();
}
}
}
//这段代码执行时会产生如下的异常信息：
Exception in thread "Thread-99249" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 10
at java.util.Vector.get(Vector.java:748)
at test.VectorSafeTest$2.run(VectorSafeTest.java:38)
at java.lang.Thread.run(Thread.java:745)
虽然Vector中的get()、remove()和size()方法都是同步的，但是在多线程的环境中，如果不在方法调用端做额外的同步措施的话，使用这段代码仍然是不安全的，因为如果另一个线程恰好在错误的时间删除了一个元素，导致序号i已经不可再用的话，在用i访问数组就会抛出一个ArrayIndexOutOfBoundsException。
/**采用同步以后的代码*/
Thread removeThread = new Thread(new Runnable() {
@Override
public void run() {
synchronized (vector){
for (int i = 0 ; i<vector.size(); i++){
vector.remove(i);
}
}
}
});
Thread printThread = new Thread(new Runnable() {
@Override
public void run() {
synchronized (vector){
for (int i = 0 ; i<vector.size(); i++){
System.out.println(vector.get(i));
}
}
}
});
相对线程安全：相对线程安全就是我们通常意义上所讲的线程安全，它需要保证对这个对象的单独操作是线程安全的，我们在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。在Java语言中，大部分的线程安全类都属于这种类型，列如Vector、HashTable、Collections的synchronizedCollection()方法包装的集合等。
线程兼容：指对象本身不是线程安全的，但是可以通过在调用端正确的使用同步手段来保证对象在并发环境中可以安全的使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。
线程对立：指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。一个线程对立的列子就是Thread类的suspend()和resume()方法，如果有两个线程同时持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发进行的话，无论调用时是否进行了同步，目标线程都是存在死锁风险的，如果suspend()中断的线程就是即将要执行resume()的那个线程，那就肯定要产生死锁了。常见的线程对立的操作还有System.setIn()、System.setOut()和System.runFinalizersOnExit()等。
5. 线程安全的实现方法
同步是保障线程安全的主要实现方法，在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个线程使用。
互斥同步：在Java中，最基本的互斥同步手段就是synchronized关键字，synchronized关键字经编译后，会在同步块前后分别形成monitorenter和monitorexit这两个字节码指令，这两个字节码指令都需要一个reference类型的参数来指明要锁定和解锁的对象。如果Java程序中的synchronized明确指定了对象参数，那就是这个对象的reference;如果没有明确指定，那就根据synchronized修饰的是实例方法还是类方法，去取对应对象实例或Class对象来作为锁对象。除synchronized外，还可以使用java.util.concurrent包中的重入锁（ReentrantLock）来实现同步，相比synchronized,ReentrantLock增加了一些高级功能：
1）等待可中断：当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
2）公平锁：多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
3）锁可以绑定多个条件：一个ReentrantLock对象可以同时绑定多个Condition对象，而在synchronized中，锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外的添加一个锁，而ReentrantLock无须这样做，只需要多次调用newCondition()方法即可。非阻塞同步：互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）乐观并发策略需要“硬件指令集的发展”才能进行。因为需要操作和冲突检测这两个步骤具备原子性，只能靠硬件来保证，硬件保证一个从语义上看来需要多次操作的行为只通过一条处理器指令就能完成，这类指令常用的有：
1）测试并设置（Test-and-Set）。
2）获取并增加（Fetch-and-Increment）。
3）交换（Swap）。
4）比较并交换（Compare-and-Swap，下文称CAS）。
5）加载链接/条件存储（Load-Linked/Store-Conditional，下文称LL/SC）。无同步方案：
线程安全与同步之间并没有直接的因果关系，同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的，比如下面两类代码：
1）可重入代码（Reentrant Code）：这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。可重入代码具有不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等共同特性。
2）线程本地存储（Thread Local Storage）：java.lang.ThreadLocal类实现了线程本地存储的功能。每一个线程的Thread对象中都有一个ThreadLocalMap对象，这个对象存储了一组以ThreadLocal.threadLocalHashCode为键，以本地线程变量为值的K-V值对，ThreadLocal对象就是当前线程的ThreadLocalMap的访问入口，每一个ThreadLocal对象都包含了一个独一无二的threadLocalHashCode值，使用这个值就可以在线程K-V值对中找回对应的本地线程变量。
6. 互斥实现的主要方式
临界区（Critical Section）：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其他线程才可以抢占。
互斥量（Mutex）：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享。
信号量（Semaphore）：与临界区和互斥量不同，可以实现多个线程同时访问公共区域数据，先设置一个访问公共区域的线程最大连接数，每有一个线程访问共享区资源数就减一，直到资源数小于等于零。
事件（Event）：通过通知操作的方式来保持线程的同步，还可以方便实现对多个线程的优先级比较的操作
7. 锁优化
高效并发是JDK1.5到JDK1.6的一个重要改进，此版本为了在线程之间更高效得共享数据，以及解决竞争问题而实现了各种锁优化技术。
-
自旋锁与自适应自旋：如果物理机器有一个以上的处理器，能让两个或以上的线程同时并行执行，我们就可以让后面请求锁的那个线程“稍等一下”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只需让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。
优缺点：如果锁被占用的时间很短，自旋等待的效果就会非常好，反之，如果锁被占用的时间很长，那么自旋的线程只会白白消耗处理器资源，而不会做任何有用的工作，反而会带来性能上的浪费。
优化：——自适应自旋。自旋的时间不再固定，却决于前一次在同一个锁上的自旋时间及锁的拥有者的状态。如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也很有可能再次成功，进而它将允许自旋等待持续相对更长时间，比如100个循环。如果对于某个锁，自旋很少成功获得过，那在以后要获取这个锁时将可能省略掉自旋过程，以避免浪费处理器资源。
锁消除：指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。锁消除的主要判定依据来源于逃逸分析的数据支持，如果判断在一段代码中，堆上的所有数据都不会逃逸出去从而被其他线程访问到，那就可以把它们当做栈上数据对待，认为它们是线程私有的，同步加锁自然就无须进行。
锁粗化：如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁操作是出现在循环体中的，那即使没有线程竞争，频繁地进行互斥同步操作也会导致不必要的性能损耗。如果虚拟机探测到有这样一串零碎的操作都对同一个对象加锁，将会把加锁同步的范围扩展（粗化）到整个操作序列的外部，如StringBuffer的多次append()操作，扩展到第一个append（）操作之前直至最后一个append（）操作之后，这样只需要加锁一次就可以了。
轻量级锁：轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量，轻量级锁并不是用来代替重量级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
-
偏向锁：它的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。如果说轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量，那偏向锁就是在无竞争的情况下把整个同步都消除掉，连CAS操作都不做了。偏向锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步。
工作原理：当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志位设为“01”，即偏向模式。同时使用CAS操作把获取到这个锁的线程的ID记录在对象的Mark Word之中，如果CAS操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行任何同步操作（例如Locking、Unlocking及对Mark Word的Update等）。当有另外一个线程去尝试获取这个锁时，偏向模式就宣告结束。根据锁对象目前是否处于被锁定的状态，撤销偏向（Revoke Bias）后恢复到未锁定（标志位为“01”）或轻量级锁定（标志位为“00”）的状态.
