CAS和Atomic包

CAS操作流程：

传入初始值和待修改值 -> 读取当前值 -> 比较当前值和传入的初始值 -> 
如果相等，将值改成待修改值；如果不等则退出

        int current = get();  //第一次读取，作为初始值
        int next = current + 1; //待修改值
        if (compareAndSet(current, next)) //第二次读取，比较初始值和当前值

JDK5之后发布了基于乐观锁思想的自旋锁（无锁）java.util.concurrent.atomic包。包里的很多操作，最后都调用到了compareAndSwapXXX方法：

//设值
AtomicXXX.compareAndSet ->
sun.misc.Unsafe.compareAndSwapXXX ->
通过JNI调用Native实现 ->
汇编指令（asm）直接支持lock cmpxchg ->  //多核处理器会加上lock保证CAS操作的原子性
如果CAS失败，自旋

cmpxchg本身并不是原子操作，但通过lock，实现了原子操作。
自旋锁就是在CAS失败的情况下重复进行CAS直到CAS成功，从而在没有锁的状态下保证对一个值的正确更新。

如果两次判断虽然值相等，但其实是经过其他线程的修改，只是恰好改回到了之前取数据时的值，这就叫ABA问题。解决问题的方法就是增加一个版本号，不仅仅通过检查值得变化来确定是否更新。

Java对象布局

通过JOL查看没上锁的Object对象布局（64位系统）：

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

对象在内存中的布局

markword：记录hashcode、GC的分代年龄信息（4bit，记录没能被GC的次数。几次被强制GC可配置）和锁信息。Object中占8byte
class printer：类型指针信息。指针大小也和系统总线长度有关，如果是64位系统，指针大小应该是8byte。但默认JVM开启了CompressedClassPointers，class printer中的指针大小会被压缩成4byte。Object中占4byte
Instance data：对象中的成员数据。默认开启CompressedOops后，普通成员变量指针也会被压缩成4byte。Object中占0byte
padding：对齐位。对象大小需要能被总整byte数整除。比如64位系统，总线是64/8=8byte，所以对象大小需要能被8整除。Object中占4byte

synchronized

查看汇编指令，synchronized关键字在同步代码块前后加入了monitorenter和monitorexit这两个指令。monitorenter指令会获取锁对象，如果获取到了锁对象，就将锁计数器加1，未获取到则会阻塞当前线程。monitorexit指令会释放锁对象，同时将锁计数器减1。
执行过程：
1，字节码：monitorenter moniterexit监控锁
2，锁自动升级

锁升级过程

最早synchronized一上来就是重量级锁，后来JDK优化了synchronized，有一个锁升级过程：

//new -> 只有自己用时 -> 有竞争时开抢，尝试将线程栈中Lock Record指针指向自身的markword -> 
//自旋次数超过JVM设置的次数，向内核申请重量级锁（mutex），通过队列管理请求
1)无锁态 - 2)偏向锁 - 3)轻量级锁（自旋锁、无锁） - 4)重量级锁

具体一个对象目前处于什么锁状态，可以查看对象markword中的标志位。

锁消除

StringBuffer是线程安全的，因为它的关键方法都是被synchronized修饰过的。但如果JVM发现StringBuffer没有多线程引用，就会自动消除StringBuffer对象内部的锁。

volatile

保证线程可见性（线程间数据同步）和指令有序性。
保证有序性的意义：一个对象new的过程分为三步，1）分配内存、2）初始化、3）将对象指向这块内存。因为cpu指令重排列的存在，有可能先指向一块null的内存，这时使用可能存在问题。

cache line

缓冲读数据，是按块读而不是只读所需数据。这一块数据叫cache line（缓存行），占64byte。cache line中有数据被volatile修饰，会使其他数据也有volatile修饰效果，可能导致多余的同步操作。注意缓存行对齐可以避免该问题。

cpu的乱序执行

cpu并不一定按照汇编代码顺序执行（cpu层面，只保证单个线程的处理结果符合预期），如果该特性会对结果产生不可控的影响。volatile可以避免指令重排序。
举例：

class T {
    int m = 8;
}
T t = new T();

汇编指令是先将一块内存分配给T -> 给m赋值 -> 让这块内存和t建立连接。但有可能因为指令重排序，导致建立连接后才赋值。

JSR内存屏障

根据Java Specification Requests，JVM发现有volatile修饰，就会通过以下四种内存屏障保证数据一致性：

LoadLoad、StoreStore、LoadStore、StoreLoad

LoadLoad即上一条Load指令执行完才能执行下一条load指令。具体使用：

StoreStoreBarrier       LoadLoadBarrier       
volatile写操作           volatile读操作
StoreLoadBarrier        LoadStoreBarrier

volatile和synchronized区别

volatile底层的实现，和synchronized一样，就是lock锁总线。只不过，volatile锁的是一条空指令，synchronized锁的是CAS操作，所以volatile仅仅只保证变量的读和写是原子性操作，并不能保证对变量的复合操作（修改）也是原子性的。

多线程相关api

Thread.join

A线程中B线程调用join，则A线程阻塞直到Thread执行完。期间其他线程的执行不受影响。

Thread.yield()

当前线程让出CPU时间片，重新参与竞争。

synchronized + object.wait / object.notify

锁的等待唤醒。使用前提是必须有锁。

synchronized(o) {
    o.wait();
}

notify通知其他线程；wait 让持有锁的当前线程让出锁（立马处于阻塞状态）。

LockSupport

public static void park(); // 无期限暂停当前线程
public static void unpark(Thread thread); // 恢复当前线程

AQS 非阻塞同步

AbstractQueuedSynchronizer，一个用来构建锁和同步工具的框架，包括常用的ReentrantLock、CountDownLatch、Semaphore等。底层都是通过CAS自旋实现的锁。

Lock lock = new ReentranLock(); //可以设置公平锁或非公平锁，默认非公平锁
lock.lock();
try{
    //do something
    Condition con = ReentrantLock.newCondition() //获得的Condition是一个队列
    //等待Condition的signalAll或signal唤醒
    con.await();
}finally{
    lock.unlock();
}

ReentrantLock的内部类Sync继承了AQS，分为公平锁FairSync和非公平锁NonfairSync，默认使用非公平锁。
公平锁：线程获取锁的顺序和调用lock的顺序一样，FIFO；
非公平锁：线程获取锁不严格按照排队顺序。
在ReentranLock中，申请非公平锁时会先插队，不行再排队；申请公平锁则只能靠排队。不管用哪种锁，如果第一次没有获取到锁，都会被放到一个自旋的队列中，按照顺序来不断尝试获取锁。
ReentranLock支持可重入锁，即同一线程可多次获取锁而不会引起死锁。重复获取锁的次数会被记数，释放锁时减1。

//初始化计数器总量为2
CountDownLatch countDownLatch = new CountDownLatch(2);
//计数器值减一
countDownLatch.countDown();
//阻塞，直到计数器值为0时解除
countDownLatch.await();

TransferQueue

通过TransferQueue.transfer方法发送数据并阻塞，尝试和另一个TransferQueue.transfer调用配对，配对后可以通过TransferQueue.take()获取对方的数据。

中断

在java中，从开发者角度，将中断请求发向一个线程的唯一方式是调用Thread.interrupt()方法。
非阻塞中的线程, 只是改变了中断状态, 即Thread.isInterrupted()将返回true。阻塞中的线程如果收到中断信号，会抛出InterruptedException异常将具体响应处理转移给开发者，同时把中断状态置为true
不可响应中断线程是指阻塞中的线程或者在运行线程不会对中断信号作任何响应，如输入和输出流类会阻塞等待 I/O 完成，但是它们不抛出 InterruptedException，而且在被中断的情况下也不会退出阻塞状态. 然而，对于Socket I/O，如果一个线程关闭套接字，则那个套接字上的阻塞 I/O 操作将提前结束，并抛出一个 SocketException。

存在 InterruptedException抛出的地方，如果当下不处理，要继续向上抛出InterruptedException异常，以便上层应用能检测到中断。不要丢失 InterruptedException。

LinkedBlockingQueue

两把线程锁，两个Condition：

线程池

当并发数高时建议自定义线程池，因为Executors返回的线程池对象有以下弊端：
1，FixedThreadPool和SingleThreadPool允许的请求队列长度为Integer.MAX_VALUE，可能堆积大量请求从而导致oom
2，CachedThreadPool允许的创建线程数量为Integer.MAX_VALUE，可能堆积大量请求从而导致oom
另外，线程池给的线程默认命名不利于问题调试。

其他参考：
简单聊聊JDK中的七大阻塞队列https://www.cnblogs.com/konck/p/9473677.html
有关线程池的10个问题https://www.cnblogs.com/konck/p/9473681.html

多线程与高并发知识点简述