Java语言从设计之初就把多线程作为语言的核心, 至少从以下几点可以看出:
1. Object对象的wait和notify机制。
2. Thread类在lang包中。
3. synchronized volatile关键字。虽然多线程是Java语言本身的特性，但是线程并不是Java语言独有的东西，而是操作系统的特性。Java在语言层面进行了封装，使其使用更简单。
多线程存在的价值在哪里呢？ 内存读写，磁盘IO， 网络传输的速率远远低于CPU处理数据的速度。所以在大部分场景下，CPU是闲置的。有了多线程，就可以更多地压榨CPU。所以，多线程在Web服务器，Lucene这类IO密集型的应用中大行其道。
多线程，知识点庞杂，但常用的核心知识点只有两个: 资源同步 和 线程池。
学习多线程，私以为这样的先后顺序比较好。
step1: 学习多线程的创建和运行， Thread类和Runnable接口, 通常自定义类是实现Runnable接口，并非Thread类。
public class ThreadDemo {
static class Worker impelements Runnable{
private String name;
public Worker(String name){
this.name = name;
}
public void run(){
System.out.println(this.name+": "+Thread.currentThread().getName());
}
}
public static void main(String[] args) {
Thread a1 = new Thread(new Worker("nameA"));
Thread a2 = new Thread(new Worker("nameB"));
a1.start();
a2.start();
}
}
step2: 学习synchronized/volatile关键字
由于内存读写远比CPU执行的速度慢，出于提升性能的考虑，计算机设计者在CPU和内存之间架设了缓存，就是通常我们看到的L1, L2, L3。1个CPU周期需要0.3ns，L1缓存只需要0.9ns, 内存访问需要120ns。 差距达百倍, 可见缓存对性能的提升。如果我们在一个线程里读写一个变量，将初始值加到缓存后， CPU只需和缓存之间交互就可以了。
由于线程之间并不共享缓存，所以多个线程读写同一个变量时，就有可能出现不一致的情况。多个线程出现了信息的不对称， 如何解决这个问题呢？ 就像银行办理业务一样，每个人办理业务前先取个号。这个号就类似Java里面的锁机制。 synchronized就是Java的内置锁。 volatile可以看作synchronized的简化版， 因为它只能适用于某些特定的场景:
1. 修改变量不依赖其当前的值
2. 变量不跟其他变量一起对外作为整体关于volatile的学习，个人觉得IBM的Java theory and practice Managing volatility是极好的学习资料。
step3: 学习ReentrantLock。了解了锁的使用场景后，可以先学习JUC实现的锁，最简单的就是ReentrantLock。ReentrantLock是互斥锁，可作为synchronized的代替品。
import java.util.concurrent.locks.ReentrantLock;
public class ThreadDemo {
static class Counter implements Runnable{
private int count;
private ReentrantLock lock = new ReentrantLock();
public void run(){
try{
lock.lock();
count +=1;
}finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}
public static void main(String[] args) throws InterruptedException {
Counter a1 = new Counter();
for(int i=0;i<1000;i++){
new Thread(a1).start();
}
Thread.sleep(1000);
System.out.println(a1.getCount());
}
}
使用了ReentrantLock后，最好是能理解锁的实现原理，即大名顶顶的AQS。但是学习AQS之前，需要一些预备知识。
1. volatile关键字的使用场景及限制
2. Unsafe.compareAndSwap的使用
3. Unsafe.park/unpark的使用
4. 数据结构链表的原理整个JUC的锁，线程安全的队列都是基于AQS构建的。
step4: 学习AQS的原理。AQS基于链表构建的队列来存储争用锁的线程。当线程没有获取到锁，就会使用Unsafe.park将线程挂起；其他的线程释放锁时，就会调用Unsafe.unpark将挂起的线程恢复。
step5: 了解了AQS的原理后，再学习ReentrantReadWriteLock， Semaphore, Phase, CountDownLatch, CyclicBarrier 这些同步工具，就没那么难理解了。
step6: 学习BlockingQueue及其子类。 各种阻塞队列，使用频度比较高的是ArrayBlockingQueue, LinkedBlockingQueue.
step7: 学习线程池，主要是ThreadPoolExecutor类, ThreadPoolExecutor的核心是Worker类，每个Worker对应着一个线程。需要注意的是使用ThreadPoolExecutor时，阻塞队列一定要要指定大小。不然线程池的RejectPolicy就不起作用了。 具体的细节需要更深入的分析。
关于多线程的知识点， 一篇笔记是远远不够的，本文仅仅梳理学习的脉络。
参考文档:
https://www.ibm.com/developerworks/library/j-jtp06197/index.html
原文地址：https://blog.51cto.com/sbp810050504/2360608