原创| jianshu.com/p/40d4c7aebd66
前言
因为这个订阅号换了皮肤，部分用户没有及时接受文章。可以开通这个订阅号，选择Top(明星)微信官方账号，尽快发货！
正文
如果你还对什么是线程，什么是进程有疑问，请先谷歌一下，因为这两个概念已经超出了本文的范围。
多线程只有一个目的，就是更好的利用CPU资源，因为所有的多线程代码都可以用单线程实现。其实这种说法只说对了一半，因为体现“多角色”的程序代码至少应该给每个角色一个线程给他，否则连实际场景都模拟不出来。当然也不能说用单线程就能实现：比如最常见的“生产者-消费者模型”。
很多人不清楚其中的一些概念，比如同步、并发等。为了避免误解，我们先建立一个数据字典。
多线程：是指这个程序(一个进程)运行时产生一个以上的线程。
并行和并发：
并行性：多个CPU实例或多台机器同时执行一个处理逻辑，是真正的同时性。
并发性：通过CPU调度算法，让用户看起来是在同时执行，实际上从CPU运行层面来说并不是真正的同时。并发在场景中往往有共同的资源，所以这种共同的资源往往存在瓶颈。我们将使用TPS或QPS来反映该系统的处理能力。
并发性和并行性
线程安全：通常用来描述一段代码。在并发的情况下，代码被多个线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，CPU是否够用。反之，线程不安全是指线程的调度顺序会影响最终结果，比如没有事务的转移码：
void transferMoney(用户自、用户至、浮动金额){ to.setMoney(to.getBalance金额)；from . set money(from . get balance-amount)；}同步：Java中的同步是指通过人为的控制和调度，保证多线程访问共享资源变成线程安全，从而保证结果的准确性。与上面的代码一样，只需添加@synchronized关键字。这是一个确保精确结果和提高性能的优秀程序。线程安全优先于性能。
好了，我们开始吧。我将把它分成几个部分来总结多线程涉及的内容：
1.扎马步：线的状态
2.内心术：每个物体都拥有的方法(机制)。
3.毛长权：基础螺纹类
4.九音真镜：高级多线程控件类
扎好马步：线程的状态
先来两张图：
线程状态
线程状态转换
各种状态一目了然，值得一提的是“阻塞”和“等待”的区别：
在运行的过程中，线程可能会遇到阻塞的情况。
给处于运行状态的线程添加一个同步锁，使其进入锁阻塞池，同步锁被释放到可运行状态。根据jdk源代码注释，blocked是指等待monitor(参考下图)，即线程在等待区。
在运行过程中，线程可能会遇到等待的情况。线程可以主动调用object.wait或者sleep，或者join(join的内部调用是sleep，所以可以看作是sleep的一种)进入。从jdk源代码注释来看，等待就是等待另一个线程完成一个操作，比如join等待另一个线程完成执行，object.wait等待object.notify方法执行。
这与Waiting 状态和Blocked 状态.有点混淆我个人的理解是：封锁实际上是一种等待，等待监视，但它不同于等待状态。比如三个线程进入同步块，其中两个调用object.wait并进入等待状态，这时第三个调用obj。
ect.notifyAll ，这时候前两个线程就一个转移到了 Runnable,一个转移到了 Blocked。从下文的 monitor 结构图来区别：每个 Monitor 在某个时刻，只能被一个线程拥有，该线程就是 “Active Thread”，而其它线程都是 “Waiting Thread”，分别在两个队列 “ Entry Set” 和 “Wait Set” 里面等候。在 “Entry Set” 中等待的线程状态 Blocked,从 jstack 的dump 中来看是 “Waiting for monitor entry”，而在 “Wait Set” 中等待的线程状态是 Waiting，表现在 jstack 的 dump 中是 “in Object.wait”。
此外，在 runnable 状态的线程是处于被调度的线程，此时的调度顺序是不一定的。Thread 类中的 yield 方法可以让一个 running 状态的线程转入 runnable。
内功心法：每个对象都有的方法（机制）
synchronized, wait, notify 是任何对象都具有的同步工具。让我们先来了解他们
monitor
他们是应用于同步问题的人工线程调度工具。讲其本质，首先就要明确 monitor 的概念，Java 中的每个对象都有一个监视器，来监测并发代码的重入。在非多线程编码时该监视器不发挥作用，反之如果在 synchronized 范围内，监视器发挥作用。
wait/notify 必须存在于 synchronized 块中。并且，这三个关键字针对的是同一个监视器（某对象的监视器）。这意味着 wait之后，其他线程可以进入同步块执行。
当某代码并不持有监视器的使用权时（如图中5的状态，即脱离同步块）去 wait 或 notify，会抛出java.lang.IllegalMonitorStateException。
也包括在 synchronized 块中去调用另一个对象的 wait/notify，因为不同对象的监视器不同，同样会抛出此异常。
再讲用法：
synchronized 单独使用：
代码块：如下，在多线程环境下，synchronized 块中的方法获取了 lock 实例的 monitor，如果实例相同，那么只有一个线程能执行该块内容
public class Thread1 implements Runnable { Object lock; public void run { synchronized(lock){ ..do something } } }
直接用于方法：相当于上面代码中用 lock 来锁定的效果，实际获取的是 Thread1 类的 monitor。更进一步，如果修饰的是 static 方法，则锁定该类所有实例
public class Thread1 implements Runnable { public synchronized void run { ..do something }}
synchronized, wait, notify 结合:典型场景生产者消费者问题
/** * 生产者生产出来的产品交给店员 */ public synchronized void produce { if(this.product >= MAX_PRODUCT) { try { wait; System.out.println("产品已满,请稍候再生产"); } catch(InterruptedException e) { e.printStackTrace ; } return; }
this.product++; System.out.println("生产者生产第" + this.product + "个产品."); notifyAll; //通知等待区的消费者可以取出产品了 } /** * 消费者从店员取产品 */ public synchronized void consume { if(this.product <= MIN_PRODUCT) { try { wait; System.out.println("缺货,稍候再取"); } catch (InterruptedException e) { e.printStackTrace; } return; } System.out.println("消费者取走了第" + this.product + "个产品."); this.product--; notifyAll; //通知等待去的生产者可以生产产品了 }
volatile
多线程的内存模型：main memory（主存）、working memory（线程栈），在处理数据时，线程会把值从主存 load 到本地栈，完成操作后再 save 回去 (volatile 关键词的作用：每次针对该变量的操作都激发一次 load and save) 。
volatile
针对多线程使用的变量如果不是 volatile 或者 final 修饰的，很有可能产生不可预知的结果（另一个线程修改了这个值，但是之后在某线程看到的是修改之前的值）。其实道理上讲同一实例的同一属性本身只有一个副本。但是多线程是会缓存值的，本质上，volatile 就是不去缓存，直接取值。在线程安全的情况下加 volatile 会牺牲性能。
太祖长拳：基本线程类
基本线程类指的是 Thread 类，Runnable 接口，Callable 接口
Thread 类实现了 Runnable 接口，启动一个线程的方法：
MyThread my = new MyThread; my.start;
Thread类相关方法
//当前线程可转让 cpu 控制权，让别的就绪状态线程运行（切换）public static Thread.yield//暂停一段时间public static Thread.sleep //在一个线程中调用 other.join,将等待other执行完后才继续本线程。 public join//后两个函数皆可以被打断public interrupte
关于中断：它并不像 stop 方法那样会中断一个正在运行的线程。线程会不时地检测中断标识位，以判断线程是否应该被中断（中断标识值是否为 true ）。终端只会影响到 wait 状态、sleep 状态和 join 状态。被打断的线程会抛出 InterruptedException。
Thread.interrupted 检查当前线程是否发生中断，返回boolean
synchronized 在获锁的过程中是不能被中断的。
中断是一个状态！interrupt方法只是将这个状态置为 true 而已。所以说正常运行的程序不去检测状态，就不会终止，而 wait 等阻塞方法会去检查并抛出异常。如果在正常运行的程序中添加while(!Thread.interrupted) ，则同样可以在中断后离开代码体
Thread类最佳实践：
写的时候最好要设置线程名称 Thread.name，并设置线程组 ThreadGroup，目的是方便管理。在出现问题的时候，打印线程栈 (jstack -pid) 一眼就可以看出是哪个线程出的问题，这个线程是干什么的。
如何获取线程中的异常
不能用try,catch来获取线程中的异常
Runnable
与 Thread 类似
Callable
future 模式：并发模式的一种，可以有两种形式，即无阻塞和阻塞，分别是 isDone 和 get。其中 Future 对象用来存放该线程的返回值以及状态
ExecutorService e = Executors.newFixedThreadPool(3);//submit 方法有多重参数版本，及支持 callable 也能够支持runnable 接口类型. Future future = e.submit(new myCallable);future.isDone //return true,false 无阻塞 future.get // return 返回值，阻塞直到该线程运行结束
九阴真经：高级多线程控制类
以上都属于内功心法，接下来是实际项目中常用到的工具了，Java1.5 提供了一个非常高效实用的多线程包: java.util.concurrent, 提供了大量高级工具,可以帮助开发者编写高效、易维护、结构清晰的 Java 多线程程序。
1.ThreadLocal类
用处：保存线程的独立变量。对一个线程类（继承自 Thread )当使用 ThreadLocal 维护变量时，ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。常用于用户登录控制，如记录 session 信息。
实现：每个Thread 都持有一个 TreadLocalMap 类型的变量（该类是一个轻量级的 Map，功能与 map 一样，区别是桶里放的是 entry 而不是 entry 的链表。功能还是一个 map 。）以本身为 key，以目标为 value。主要方法是 get 和 set(T a)，set 之后在 map 里维护一个threadLocal -> a，get 时将 a 返回。ThreadLocal 是一个特殊的容器。
2.原子类（AtomicInteger、AtomicBoolean……）
如果使用 atomic wrapper class 如 atomicInteger，或者使用自己保证原子的操作，则等同于 synchronized
//返回值为 booleanAtomicInteger.compareAndSet(int expect,int update)
该方法可用于实现乐观锁，考虑文中最初提到的如下场景：a 给 b 付款10元，a 扣了 10 元，b 要加 10 元。此时 c 给 b 2 元，但是 b的加十元代码约为：
if(b.value.compareAndSet(old, value)){ return ;}else{ //try again // if that fails, rollback and log}
AtomicReference
对于 AtomicReference 来讲，也许对象会出现，属性丢失的情况，即 oldObject == current，但是 oldObject.getPropertyA != current.getPropertyA。这时候，AtomicStampedReference 就派上用场了。这也是一个很常用的思路，即加上版本号
3.Lock类
lock: 在 java.util.concurrent 包内。共有三个实现：
ReentrantLock
ReentrantReadWriteLock.ReadLock
ReentrantReadWriteLock.WriteLock
主要目的是和 synchronized 一样， 两者都是为了解决同步问题，处理资源争端而产生的技术。功能类似但有一些区别。
区别如下：
1.lock 更灵活，可以自由定义多把锁的枷锁解锁顺（synchronized 要按照先加的后解顺序）
2.提供多种加锁方案，lock 阻塞式, trylock 无阻塞式, lockInterruptily 可打断式， 还有 trylock 的带超时时间版本
3.本质上和监视器锁（即 synchronized 是一样的）
4.能力越大，责任越大，必须控制好加锁和解锁，否则会导致灾难。
5.和 Condition 类的结合。
6.性能更高，对比如下图：
synchronized和Lock性能对比
ReentrantLock
可重入的意义在于持有锁的线程可以继续持有，并且要释放对等的次数后才真正释放该锁。
使用方法是：
1.先 new 一个实例
static ReentrantLock r=new ReentrantLock;
2.加锁
r.lock或 r.lockInterruptibly;
此处也是个不同，后者可被打断。当 a 线程 lock 后，b 线程阻塞，此时如果是 lockInterruptibly，那么在调用 b.interrupt 之后，b 线程退出阻塞，并放弃对资源的争抢，进入 catch 块。（如果使用后者，必须 throw interruptable exception 或 catch）
3.释放锁
r.unlock
必须做！何为必须做呢，要放在 finally 里面。以防止异常跳出了正常流程，导致灾难。这里补充一个小知识点，finally 是可以信任的：经过测试，哪怕是发生了 OutofMemoryError ，finally 块中的语句执行也能够得到保证。
ReentrantReadWriteLock
可重入读写锁（读写锁的一个实现）
ReentrantReadWriteLock lock = new ReentrantReadWriteLockReadLock r = lock.readLock; WriteLock w = lock.writeLock;
两者都有 lock,unlock 方法。写写，写读互斥；读读不互斥。可以实现并发读的高效线程安全代码
4.容器类
这里就讨论比较常用的两个：
BlockingQueue
ConcurrentHashMap
BlockingQueue
阻塞队列。该类是 java.util.concurrent 包下的重要类，通过对 Queue 的学习可以得知，这个 queue 是单向队列，可以在队列头添加元素和在队尾删除或取出元素。类似于一个管道，特别适用于先进先出策略的一些应用场景。普通的 queue 接口主要实现有 PriorityQueue（优先队列），有兴趣可以研究
BlockingQueue 在队列的基础上添加了多线程协作的功能：
BlockingQueue
除了传统的 queue 功能（表格左边的两列）之外，还提供了阻塞接口 put 和 take，带超时功能的阻塞接口 offer 和 poll。put 会在队列满的时候阻塞，直到有空间时被唤醒；take 在队 列空的时候阻塞，直到有东西拿的时候才被唤醒。用于生产者-消费者模型尤其好用，堪称神器。
常见的阻塞队列有：
ArrayListBlockingQueue
LinkedListBlockingQueue
DelayQueue
SynchronousQueue
** ConcurrentHashMap**
高效的线程安全哈希 map。请对比 hashTable , concurrentHashMap, HashMap
5.管理类
管理类的概念比较泛，用于管理线程，本身不是多线程的，但提供了一些机制来利用上述的工具做一些封装。
了解到的值得一提的管理类：ThreadPoolExecutor 和 JMX框架下的系统级管理类 ThreadMXBean
ThreadPoolExecutor
如果不了解这个类，应该了解前面提到的 ExecutorService，开一个自己的线程池非常方便
ExecutorService e = Executors.newCachedThreadPool; ExecutorService e =Executors.newSingleThreadExecutor; ExecutorService e = Executors.newFixedThreadPool(3); // 第一种是可变大小线程池，按照任务数来分配线程， // 第二种是单线程池，相当于 FixedThreadPool(1) // 第三种是固定大小线程池。 // 然后运行 e.execute(new MyRunnableImpl);
该类内部是通过 ThreadPoolExecutor 实现的，掌握该类有助于理解线程池的管理，本质上，他们都是 ThreadPoolExecutor 类的各种实现版本。请参见 javadoc：
ThreadPoolExecutor参数解释
翻译一下：
corePoolSize: 池内线程初始值与最小值，就算是空闲状态，也会保持该数量线程。
maximumPoolSize: 线程最大值，线程的增长始终不会超过该值。
keepAliveTime: 当池内线程数高于 corePoolSize 时，经过多少时间多余的空闲线程才会被回收。回收前处于 wait 状态
unit：
时间单位，可以使用 TimeUnit 的实例，如 TimeUnit.MILLISECONDS
workQueue: 待入任务（Runnable）的等待场所，该参数主要影响调度策略，如公平与否，是否产生饿死 (starving)
threadFactory: 线程工厂类，有默认实现，如果有自定义的需要则需要自己实现 ThreadFactory 接口并作为参数传入。
请注意：该类十分常用，作者80%的多线程问题靠他。
