@CallerSensitive
public static Unsafe getUnsafe() {
	Class var0 = Reflection.getCallerClass();
	// 是不是Bootstrap类加载器加载的
	if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
		throw new SecurityException("Unsafe");
	} else {
		return theUnsafe;
	}
}

// AtomicInteger
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
private volatile int value;

static {
	try {
		valueOffset = unsafe.objectFieldOffset
			(AtomicInteger.class.getDeclaredField("value"));
	} catch (Exception ex) { throw new Error(ex); }
}

public final int getAndSet(int newValue) {
	return unsafe.getAndSetInt(this, valueOffset, newValue);
}

public final boolean compareAndSet(int expect, int update) {
	return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

// AtomicIntegerArray
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final int base = unsafe.arrayBaseOffset(int[].class);
private static final int shift;
private final int[] array;

static {
	int scale = unsafe.arrayIndexScale(int[].class);
	if ((scale & (scale - 1)) != 0)
		throw new Error("data type scale not a power of two");
	shift = 31 - Integer.numberOfLeadingZeros(scale);
}

private long checkedByteOffset(int i) {
	if (i < 0 || i >= array.length)
		throw new IndexOutOfBoundsException("index " + i);
	return byteOffset(i);
}

private static long byteOffset(int i) {
	return ((long) i << shift) + base;
}

public final int getAndSet(int i, int newValue) {
	return unsafe.getAndSetInt(array, checkedByteOffset(i), newValue);
}

transient volatile Cell[] cells;
transient volatile long base;

// Contended解决伪共享
@sun.misc.Contended static final class Cell {
	volatile long value;
	Cell(long x) { value = x; }
	final boolean cas(long cmp, long val) {
		return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
	}

	// Unsafe mechanics
	private static final sun.misc.Unsafe UNSAFE;
	private static final long valueOffset;
	static {
		try {
			UNSAFE = sun.misc.Unsafe.getUnsafe();
			Class<?> ak = Cell.class;
			valueOffset = UNSAFE.objectFieldOffset
				(ak.getDeclaredField("value"));
		} catch (Exception e) {
			throw new Error(e);
		}
	}
}

public void add(long x) {
	Cell[] as; long b, v; int m; Cell a;
	// 并发量不大时，直接CAS，与AtomicLong一样
	if ((as = cells) != null || !casBase(b = base, b + x)) {
		boolean uncontended = true;
		// 当竞争激烈到一定程度无法对base进行累加操作时，会对cells数组中某个元素进行更新
		if (as == null || (m = as.length - 1) < 0 ||
			(a = as[getProbe() & m]) == null ||
			!(uncontended = a.cas(v = a.value, v + x)))
			// 用一个死循环对cells数组中的元素进行操作：
			// 当要更新的位置的元素为空时插入新的cell元素，否则在该位置进行CAS的累加操作
			// 如果CAS操作失败并且数组大小没有超过核数就扩容cells数组当要更新的位置的元素为空时插入新的cell元素
			// 否则在该位置进行CAS的累加操作，如果CAS操作失败并且数组大小没有超过核数就扩容cells数组
			longAccumulate(x, null, uncontended);
	}
}

// 对Striped64的BASE的值(base值所对应的内存偏移量)进行累加并返回是否成功，
final boolean casBase(long cmp, long val) {
	return UNSAFE.compareAndSwapLong(this, BASE, cmp, val);
}

public long longValue() {
	return sum();
}

// 返回的是base和cells数组中所有元素的和
public long sum() {
	Cell[] as = cells; Cell a;
	long sum = base;
	if (as != null) {
		for (int i = 0; i < as.length; ++i) {
			if ((a = as[i]) != null)
				sum += a.value;
		}
	}
	return sum;
}

// 内部类Node
static final class Node {
	/** Marker to indicate a node is waiting in shared mode */
	static final Node SHARED = new Node();
	/** Marker to indicate a node is waiting in exclusive mode */
	static final Node EXCLUSIVE = null;

	volatile int waitStatus;
	volatile Node prev;
	volatile Node next;
	volatile Thread thread;
	Node nextWaiter;
}

/**
 * The synchronization state.
 */
private volatile int state;

public final void acquire(int arg) {
	// 尝试获取
	if (!tryAcquire(arg) &&
		// 1. addWaiter创建独占锁节点(线程+节点类型)，加入到队列尾部，如果有并发则自旋去修改
		// 2. acquireQueued将线程挂起
		acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
		// 中断
		selfInterrupt();
}

// 留给子类实现，由于有两类功能，因此非抽象方法让所有子类都去实现
// 子类可通过state判断
protected boolean tryAcquire(int arg) {
	throw new UnsupportedOperationException();
}

final boolean acquireQueued(final Node node, int arg) {
	boolean failed = true;
	try {
		boolean interrupted = false;
		for (;;) {
			// 获取node的前一个节点p
			final Node p = node.predecessor();
			// 如果节点p是头节点，说明是队列中第一个"有效的"节点，因此尝试获取tryAcquire
			if (p == head && tryAcquire(arg)) {
				// 成功后将自己设为头节点，清空thread和prev
				setHead(node);
				p.next = null; // help GC
				failed = false;
				return interrupted;
			}
			// 确认/更新获取失败节点的状态，是否被取消(跳过)，是否已准备好挂起(返回true)
			if (shouldParkAfterFailedAcquire(p, node) &&
				// 借助JUC包下的LockSopport类的静态方法Park挂起当前线程
				parkAndCheckInterrupt())
				interrupted = true;
		}
	} finally {
		if (failed)
			// 取消请求，将当前节点从队列中移除
			cancelAcquire(node);
	}
}

public final boolean release(int arg) {
	// 同样是由子类实现
	if (tryRelease(arg)) {
		Node h = head;
		if (h != null && h.waitStatus != 0)
			// 找到AQS的头节点，唤醒它的下一个节点
			unparkSuccessor(h);
		return true;
	}
	return false;
}

private void unparkSuccessor(Node node) {
	int ws = node.waitStatus;
	if (ws < 0)
		compareAndSetWaitStatus(node, ws, 0);

	Node s = node.next;
	if (s == null || s.waitStatus > 0) {
		s = null;
		for (Node t = tail; t != null && t != node; t = t.prev)
			if (t.waitStatus <= 0)
				s = t;
	}
	if (s != null)
		LockSupport.unpark(s.thread);
}

// 例如输入5，代表初始化5个，countDown为0后await返回
public CountDownLatch(int count) {
	if (count < 0) throw new IllegalArgumentException("count < 0");
	this.sync = new Sync(count);
}

private static final class Sync extends AbstractQueuedSynchronizer {
	Sync(int count) {
		// 很明显就是修改AQS的state
		setState(count);
	}
}

public void await() throws InterruptedException {
	sync.acquireSharedInterruptibly(1);
}

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
	// 检查下线程是否被中断
	if (Thread.interrupted())
		throw new InterruptedException();
	if (tryAcquireShared(arg) < 0)
		// 获取共享锁失败，即state不为0，意味着计数器还不为0，将当前线程放入到队列中去
		doAcquireSharedInterruptibly(arg);
}

// await方法的获取方式更像是在获取一个独占锁，不过为0时可以多个线程调用，同时等待返回
protected int tryAcquireShared(int acquires) {
	return (getState() == 0) ? 1 : -1;
}

private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
	// 标示这是一个共享节点
	final Node node = addWaiter(Node.SHARED);
	boolean failed = true;
	try {
		for (;;) {
			final Node p = node.predecessor();
			// 如果新建节点的前一个节点，就是Head，说明当前节点是AQS队列中等待获取锁的第一个节点，按照FIFO可直接尝试获取锁
			if (p == head) {
				int r = tryAcquireShared(arg);
				if (r >= 0) {
					// 获取成功，需要将当前节点设置为AQS队列中的第一个节点。队列的头节点表示正在获取锁的节点
					setHeadAndPropagate(node, r);
					p.next = null; // help GC
					failed = false;
					return;
				}
			}
			// 检查下是否需要将当前节点挂起
			if (shouldParkAfterFailedAcquire(p, node) &&
				parkAndCheckInterrupt())
				throw new InterruptedException();
		}
	} finally {
		if (failed)
			cancelAcquire(node);
	}
}

private void setHeadAndPropagate(Node node, int propagate) {
	Node h = head; // Record old head for check below
	setHead(node);

	if (propagate > 0 || h == null || h.waitStatus < 0 ||
		(h = head) == null || h.waitStatus < 0) {
		Node s = node.next;
		// 将当前节点的下一个节点取出来，如果符合条件，做releaseShared操作
		// 因为共享功能和独占功能不同，独占有且只有一个线程(持有锁的线程重复调用lock会被包装成多个节点在AQS队列中)能获取锁
		// 而共享状态是可以被共享的，AQS队列中的其他节点也应能第一时间知道状态的变化。因此节点自身获取共享锁成功后，唤醒下一个共享类型节点的操作，实现共享状态的向后传递
		if (s == null || s.isShared())
			doReleaseShared();
	}
}

private void doReleaseShared() {
	for (;;) {
		Node h = head;
		if (h != null && h != tail) {
			int ws = h.waitStatus;
			// 如果头节点是SIGNAL(-1)，则它可能正在等待一个信号，或在等待被唤醒，因此做两件事：
			// 1.重置waitStatus标志位  2.重置成功后, 唤醒下一个节点 
			if (ws == Node.SIGNAL) {
				if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
					continue;            // loop to recheck cases
				unparkSuccessor(h);
			}
			// 如果头节点的waitStatus是出于重置状态waitStatus==0的，将其设置为"传播"状态，即需要将状态向后一个节点传播
			else if (ws == 0 &&
					 !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
				continue;                // loop on failed CAS
		}
		if (h == head)                   // loop if head changed
			break;
	}
}

// 响应中断。每次循环时，会检查当前线程的中断状态，以实现对线程中断的响应
doAcquireSharedInterruptibly
// 限制等待时间，超出时间后，方法返回
doAcquireSharedNanos

if (nanosTimeout <= 0L)
	return false;
// 算出超时时间
final long deadline = System.nanoTime() + nanosTimeout;
// 自旋...
for (;;) {
	// tryAcquireShared... 
	nanosTimeout = deadline - System.nanoTime();
	// 超时返回
	if (nanosTimeout <= 0L)
		return false;
	// 如果超时时间小于自旋时间(1000ns)，则不需要挂起线程
	if (shouldParkAfterFailedAcquire(p, node) &&
		nanosTimeout > spinForTimeoutThreshold)
		LockSupport.parkNanos(this, nanosTimeout);
}

public void countDown() {
	sync.releaseShared(1);
}

public final boolean releaseShared(int arg) {
	// 尝试去释放锁，同样由子类实现
	// 如果state为0，对CountDownLatch来说：所有的子线程已经执行完毕，可以唤醒调用await()方法的线程了，而这些线程正在 AQS的队列中，且被挂起
	if (tryReleaseShared(arg)) {
		doReleaseShared();
		return true;
	}
	return false;
}

// CountDownLatch，尝试-1
protected boolean tryReleaseShared(int releases) {
	// Decrement count; signal when transition to zero
	for (;;) {
		int c = getState();
		if (c == 0)
			return false;
		int nextc = c-1;
		if (compareAndSetState(c, nextc))
			return nextc == 0;
	}
}

public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
}

public void lock() {
	// FairSync或NonfairSync重写的lock方法
	sync.lock();
}

// FairSync
final void lock() {
	acquire(1);
}

protected final boolean tryAcquire(int acquires) {
	final Thread current = Thread.currentThread();
	// 获取AQS中的标志位
	int c = getState();
	if (c == 0) {
		// 如果队列中没有其他线程，说明没有线程正在占有锁！
		if (!hasQueuedPredecessors() &&
			// 修改一下状态位，这里的acquires是在lock的时候传递来的，即1
			compareAndSetState(0, acquires)) {
			// 如果CAS操作状态更新成功则代表当前线程获取锁，将当前线程设到AQS的一个变量中，说明这个线程拿走了锁
			// exclusiveOwnerThread = thread;
			setExclusiveOwnerThread(current);
			return true;
		}
	}
	// 如果不为0说明锁已经被拿走了，但因为ReentrantLock是重入锁，所以还要判断获取锁的线程是不是当前请求锁的线程
	else if (current == getExclusiveOwnerThread()) {
		// 是的情况下，acquires累加在state上
		int nextc = c + acquires;
		if (nextc < 0)
			throw new Error("Maximum lock count exceeded");
		setState(nextc);
		return true;
	}
	return false;
}


// NonfairSync
final void lock() {
	if (compareAndSetState(0, 1))
		// 如果CAS操作状态更新成功则代表当前线程获取锁，将当前线程设到AQS的一个变量中，说明这个线程拿走了锁
		setExclusiveOwnerThread(Thread.currentThread());
	else
		acquire(1);
}

public void unlock() {
	// 实际执行AQS的release方法
	sync.release(1);
}

protected final boolean tryRelease(int releases) {
	int c = getState() - releases;
	if (Thread.currentThread() != getExclusiveOwnerThread())
		throw new IllegalMonitorStateException();
	boolean free = false;
	if (c == 0) {
		free = true;
		setExclusiveOwnerThread(null);
	}
	setState(c);
	return free;
}

public ThreadPoolExecutor(int corePoolSize, // 核心线程池大小
						  int maximumPoolSize, // 最大线程池大小
						  long keepAliveTime, // 线程最大空闲时间
						  TimeUnit unit, // 时间单位
						  BlockingQueue<Runnable> workQueue, // 线程等待队列
						  ThreadFactory threadFactory, // 线程创建工厂
						  RejectedExecutionHandler handler) { // 拒绝策略
	if (corePoolSize < 0 ||
		maximumPoolSize <= 0 ||
		maximumPoolSize < corePoolSize ||
		keepAliveTime < 0)
		throw new IllegalArgumentException();
	if (workQueue == null || threadFactory == null || handler == null)
		throw new NullPointerException();
	this.acc = System.getSecurityManager() == null ?
			null :
			AccessController.getContext();
	this.corePoolSize = corePoolSize;
	this.maximumPoolSize = maximumPoolSize;
	this.workQueue = workQueue;
	this.keepAliveTime = unit.toNanos(keepAliveTime);
	this.threadFactory = threadFactory;
	this.handler = handler;
}

ExecutorService es = Executors.newFixedThreadPool(10);

// 适用场景：可用于Web服务瞬时削峰，但需注意长时间持续高峰情况造成的队列阻塞
public static ExecutorService newFixedThreadPool(int nThreads) {
	return new ThreadPoolExecutor(nThreads, nThreads, // 固定核心线程
								  0L, TimeUnit.MILLISECONDS,
								  new LinkedBlockingQueue<Runnable>()); // 无界阻塞队列
}

// 适用场景：快速处理大量耗时较短的任务，如Netty的NIO接受请求时可使用
public static ExecutorService newCachedThreadPool() {
	return new ThreadPoolExecutor(0, Integer.MAX_VALUE,	// 线程数量几乎无限制
								  60L, TimeUnit.SECONDS,
								  new SynchronousQueue<Runnable>()); // 同步队列，入队出队必须同时传递
}

// 支持任务周期性调度的线程池。对比Timer而言是多线程、任务之间不影响、相对时间、异常无影响
public ScheduledThreadPoolExecutor(int corePoolSize) {
	super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
		  new DelayedWorkQueue());
}

public FutureTask(Callable<V> callable) {
	if (callable == null)
		throw new NullPointerException();
	this.callable = callable;
	this.state = NEW;       // ensure visibility of callable
}

public FutureTask(Runnable runnable, V result) {
	this.callable = Executors.callable(runnable, result);
	this.state = NEW;       // ensure visibility of callable
}

public void run() {
	if (state != NEW ||
		!UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
		return;
	try {
		Callable<V> c = callable;
		if (c != null && state == NEW) {
			V result;
			boolean ran;
			try {
				// 1、获取返回值
				result = c.call();
				ran = true;
			} catch (Throwable ex) {
				result = null;
				ran = false;
				// 2、FutureTask的异常处理
				setException(ex);
			}
			if (ran)
				// 3、设置返回值
				set(result);
		}
	} finally {
		// runner must be non-null until state is settled to
		// prevent concurrent calls to run()
		runner = null;
		// state must be re-read after nulling runner to prevent
		// leaked interrupts
		int s = state;
		if (s >= INTERRUPTING)
			handlePossibleCancellationInterrupt(s);
	}
}

protected void setException(Throwable t) {
	if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
		outcome = t;
		// 设置为异常状态
		UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL);
		finishCompletion();
	}
}

protected void set(V v) {
	if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
		outcome = v;
		// 设置为正常结束状态
		UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
		finishCompletion();
	}
}

public V get() throws InterruptedException, ExecutionException {
	int s = state;
	// 未完成：status为NEW和COMPLETING，则进入阻塞状态，等待完成
	if (s <= COMPLETING)
		s = awaitDone(false, 0L);
	return report(s);  //判断处理返回值
}

private V report(int s) throws ExecutionException {
	Object x = outcome;
	// 根据state判断线程处理状态，并对outcome返回结果进行强转。
	if (s == NORMAL)
		return (V)x;
	if (s >= CANCELLED)
		throw new CancellationException();
	throw new ExecutionException((Throwable)x); //在主线程中抛出异常
}

// ThreadLocalMap
private Entry[] table;

// 是用ThreadLocal的弱引用为key
static class Entry extends WeakReference<ThreadLocal<?>> {
	/** The value associated with this ThreadLocal. */
	Object value;
	Entry(ThreadLocal<?> k, Object v) {
		super(k);
		value = v;
	}
}

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	table = new Entry[INITIAL_CAPACITY];
	int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
	table[i] = new Entry(firstKey, firstValue);
	size = 1;
	setThreshold(INITIAL_CAPACITY);
}

public void set(T value) {
	// 获取当前线程（调用者线程）
	Thread t = Thread.currentThread();
	// 以当前线程作为key值，去查找对应的线程变量，找到对应的map
	ThreadLocalMap map = getMap(t);
	if (map != null)
		map.set(this, value);
	else
		createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
	return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
	t.threadLocals = new ThreadLocalMap(this, firstValue);
}

public T get() {
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null) {
		ThreadLocalMap.Entry e = map.getEntry(this);
		if (e != null) {
			T result = (T)e.value;
			return result;
		}
	}
	// 执行到此处，threadLocals为null，初始化当前线程的threadLocals变量
	return setInitialValue();
}

private Entry getEntry(ThreadLocal<?> key) {
	int i = key.threadLocalHashCode & (table.length - 1);
	Entry e = table[i];
	if (e != null && e.get() == key)
		return e;
	else
		return getEntryAfterMiss(key, i, e);
}

 /**
 * 该函数在父线程创建子线程，向子线程复制InheritableThreadLocal变量时使用
 */
protected T childValue(T parentValue) {
	return parentValue;
}

/**
 * 由于重写了getMap，操作InheritableThreadLocal时，
 * 将只影响Thread类中的inheritableThreadLocals变量，
 * 与threadLocals变量不再有关系
 */
ThreadLocalMap getMap(Thread t) {
   return t.inheritableThreadLocals;
}

/**
 * 类似于getMap，操作InheritableThreadLocal时，
 * 将只影响Thread类中的inheritableThreadLocals变量，
 * 与threadLocals变量不再有关系
 */
void createMap(Thread t, T firstValue) {
	t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}

/**
 * 初始化一个线程.
 * 此函数有两处调用，
 * 1、init()，不传AccessControlContext，inheritThreadLocals=true
 * 2、		  传递AccessControlContext，inheritThreadLocals=false
 */
private void init(ThreadGroup g, Runnable target, String name,
				  long stackSize, AccessControlContext acc,
				  boolean inheritThreadLocals) {
	// ...
	// 采用默认方式产生子线程时，inheritThreadLocals=true；若此时父线程inheritableThreadLocals不为空，则将父线程inheritableThreadLocals传递至子线程，子线程将parentMap中的所有记录逐一复制至自身线程
	if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
	// ...
}