< div style = "color:#16b0ff;font-size:50px;font-weight: 900;text-shadow: 5px 5px 10px var(--theme-color);font-family: 'Comic Sans MS';" > JAVA< / div >
< span style = "color:#16b0ff;font-size:20px;font-weight: 900;font-family: 'Comic Sans MS';" > Introduction</ span > ： `JUC` 、`Thread`、`Lock`、`I/O` 等总结！
[TOC]
# J.U.C
## 并发特性
JAVA里面进行多线程通信的主要方式就是 `共享内存` 的方式，共享内存主要的关注点有两个：`可见性` 和 `有序性` 。加上复合操作的 `原子性` ， （ ， ） ：
- ** 原子性（ ） ：
- ** 有序性（ ）
- ** 可见性（ ）
**① 重排序**
指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段。从JAVA源码到最终实际执行的指令序列， （ ） ：
**指令重排序分类**
- **编译器优化的重排序**：编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序;
- **指令级并行的重排序**：现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序;
- **内存系统的重排序**：由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行的。
**② 顺序一致性**
顺序一致性内存模型是一个理论参考模型，在设计的时候，处理器的内存模型和编程语言的内存模型都会以顺序一致性内存模型作为参照。顺序一致性特征如下：
- 一个线程中的所有操作必须按照程序的顺序来执行
- （不管程序是否同步）所有线程都只能看到一个单一的操作执行顺序。在顺序一致性的内存模型中，每个操作必须原子执行并且立刻对所有线程可见
## Unsafe
Java不能直接访问操作系统底层，
- **通过Unsafe类可以分配内存，
类中提供的3个本地方法allocateMemory(申请)、reallocateMemory(扩展)、freeMemory(销毁)分别用于分配内存， ，
- **可以定位对象某字段的内存位置，也可以修改对象的字段值，即使它是私有的**
- 字段的定位
- 数组元素定位
- **挂起与恢复**
将一个线程进行挂起是通过park方法实现的， ， ， ， ，
- **CAS操作**
是通过compareAndSwapXXX方法实现的
## LockSupport
LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，
LockSupport和每个使用它的线程都与一个许可(permit)关联。permit相当于1， ， ， ， ， （ ， ， ） ，
park()和unpark()不会有 `Thread.suspend` 和 `Thread.resume` 所可能引发的死锁问题，由于许可的存在，调用 park 的线程和另一个试图将其 unpark 的线程之间的竞争将保持活性。
## CAS机制
CAS(`Compare And Swap`，即比较并交换)，是解决多线程并行情况下使用锁造成性能损耗的一种机制。其原理是利用`sun.misc.Unsafe.java` 类通过JNI来调用硬件级别的原子操作来实现CAS(即CAS是借助C来调用CPU底层指令实现的)。
**CAS机制=比较并交换+乐观锁机制+锁自旋**
**设计思想**：如果`内存位置` 的值与 `预期原值` 相匹配，那么处理器会自动将该位置值更新为新值，否则处理器不做任何操作。
ReentrantLock、ReentrantReadWriteLock 都是基于 AbstractQueuedSynchronizer (AQS)，而 AQS 又是基于 CAS。CAS 的全称是 Compare And Swap（ ） ， ， ， ， ， ， （ ）
**CAS特性**
- 通过JNI借助C来调用CPU底层指令实现
- 非阻塞算法
- 非独占锁
**CAS缺陷**
- **ABA问题**： ； ， ； ， ，
- 使用数据乐观锁的方式给它加一个版本号或者时间戳，如使用 `AtomicStampedReference<V>` 解决
- **自旋消耗资源**： ， ，
- 破坏掉死循环， ，
- **只能保证一个共享变量的原子操作**
- 可以加锁来解决
- 封装成对象类解决，如使用 `AtomicReference<V>` 解决
## AQS框架
### 基础
AbstractQueuedSynchronizer抽象同步队列简称AQS， ，
AQS定义了一套多线程访问共享资源的同步模板， ， ， （ ） ， ， ，
三部分组成：`volatile int state同步状态`、`Node组成的CLH队列`、`ConditionObject条件变量`（ ）
**状态**
- `getState()` ：返回同步状态
- `setState(int newState)` ：设置同步状态
- `compareAndSetState(int expect, int update)` ：
- `isHeldExclusively()` ：当前线程是否持有资源
**独占资源（不响应线程中断）**
- `tryAcquire(int arg)` ：独占式获取资源，子类实现
- `acquire(int arg)` ：独占式获取资源模板
- `tryRelease(int arg)` ：独占式释放资源，子类实现
- `release(int arg)` ：独占式释放资源模板
**共享资源（不响应线程中断）**
- `tryAcquireShared(int arg)` ： ， ， ，
- `acquireShared(int arg)` ：共享形获取资源模板
- `tryReleaseShared(int arg)` ：共享式释放资源，子类实现
- `releaseShared(int arg)` ：共享式释放资源模板
### 同步状态
在AQS中维护了一个同步状态变量state， ， ， ， ， ， ， ， ，
- ReentrantLock的state用来表示是否有锁资源
- ReentrantReadWriteLock的state高16位代表读锁状态，
- Semaphore的state用来表示可用信号的个数
- CountDownLatch的state用来表示计数器的值
### CLH队列
CLH是AQS内部维护的FIFO（ ） （ ） ， ， ， ， ， ， ， ：
- 先进先出保证了公平性
- 非阻塞的队列， ，
- 采用了自旋锁思想，
### Node内部类
`Node` 是`AQS`的内部类，每个等待资源的线程都会封装成`Node`节点组成`CLH`队列、等待队列，所以说`Node`是非常重要的部分，理解它是理解`AQS`的第一步。
**waitStatus等待状态如下**
**nextWaiter特殊标记**
- **`Node`在`CLH`队列时，`nextWaiter`表示共享式或独占式标记**
- **`Node`在条件队列时，`nextWaiter`表示下个`Node`节点指针**
### 流程概述
线程获取资源失败，封装成`Node`节点从`CLH`队列尾部入队并阻塞线程，某线程释放资源时会把`CLH`队列首部`Node`节点关联的线程唤醒（**此处的首部是指第二个节点，后面会细说**），再次获取资源。
### 入队
获取资源失败的线程需要封装成`Node`节点，接着尾部入队，在`AQS`中提供`addWaiter`函数完成`Node`节点的创建与入队。
```java
/**
* @description: Node节点入队-CLH队列
* @param mode 标记Node.EXCLUSIVE独占式 or Node.SHARED共享式
*/
private Node addWaiter(Node mode) {
// 根据当前线程创建节点，
Node node = new Node(Thread.currentThread(), mode);
// 获取尾节点
Node pred = tail;
if (pred != null) {
// 如果尾节点不等于null，
node.prev = pred;
// 通过CAS把尾节点指向当前节点
if (compareAndSetTail(pred, node)) {
// 之前尾节点的下个节点指向当前节点
pred.next = node;
return node;
}
}
// 如果添加失败或队列不存在，
enq(node);
return node;
}
```
添加节点的时候，如果从`CLH`队列已经存在，通过`CAS`快速将当前节点添加到队列尾部，如果添加失败或队列不存在，则指向`enq`函数自旋入队。
```java
/**
* @description: 自旋cas入队
* @param node 节点
*/
private Node enq(final Node node) {
for (;;) { //循环
//获取尾节点
Node t = tail;
if (t == null) {
//如果尾节点为空， ，
if (compareAndSetHead(new Node()))
//cas成功，
tail = head;
} else {
//当前节点的前驱节点设指向之前尾节点
node.prev = t;
//cas设置把尾节点指向当前节点
if (compareAndSetTail(t, node)) {
//cas成功，
t.next = node;
return t;
}
}
}
}
```
通过自旋`CAS`尝试往队列尾部插入节点，直到成功，自旋过程如果发现`CLH`队列不存在时会初始化`CLH`队列，入队过程流程如下图：
第一次循环
- 刚开始C L H队列不存在，
- 要初始化C L H队列， ，
第二次循环
- 当前线程节点的前驱节点指向尾部节点（哨兵节点）
- 设置当前线程节点为尾部，
- 前尾部节点的后驱节点指向当前线程节点（当前尾部节点）
最后结合addWaiter与enq函数的入队流程图如下
### 出队
`CLH` 队列中的节点都是获取资源失败的线程节点，当持有资源的线程释放资源时，会将`head.next`指向的线程节点唤醒（**`CLH`队列的第二个节点**），如果唤醒的线程节点获取资源成功，线程节点清空信息设置为头部节点（**新哨兵节点**），原头部节点出队（**原哨兵节点**）
```java
//1.获取前驱节点
final Node p = node.predecessor();
//如果前驱节点是首节点，获取资源（子类实现）
if (p == head & & tryAcquire(arg)) {
//2.获取资源成功，设置当前节点为头节点，清空当前节点的信息，把当前节点变成哨兵节点
setHead(node);
//3.原来首节点下个节点指向为null
p.next = null; // help GC
//4.非异常状态，
failed = false;
//5.返回线程中断状态
return interrupted;
}
private void setHead(Node node) {
//节点设置为头部
head = node;
//清空线程
node.thread = null;
//清空前驱节点
node.prev = null;
}
```
只需要关注`1~3`步骤即可，过程非常简单，假设获取资源成功，更换头部节点，并把头部节点的信息清除变成哨兵节点，注意这个过程是不需要使用`CAS`来保证，因为只有一个线程能够成功获取到资源。
### 条件变量
Object的wait、notify函数是配合Synchronized锁实现线程间同步协作的功能， ， ， ，
如上图所示， ， ， ， ， ， ，
当某个线程执行了ConditionObject的await函数， ， ， ， ，
### 模板方法
`AQS` 采用了模板方法设计模式，提供了两类模板，一类是独占式模板，另一类是共享形模式，对应的模板函数如下
- 独占式
- **`acquire`获取资源**
- **`release`释放资源**
- 共享式
- **`acquireShared`获取资源**
- **`releaseShared`释放资源**
#### 独占式获取资源
`acquire` 是个模板函数，模板流程就是线程获取共享资源，如果获取资源成功，线程直接返回，否则进入`CLH`队列，直到获取资源成功为止，且整个过程忽略中断的影响，`acquire`函数代码如下
- 执行tryAcquire函数， ， ， ，
- 执行addWaiter函数（ ） ， ，
- 执行acquireQueued函数，
- 如果acquireQueued函数中获取资源成功， ，
`acquire` 函数的大致流程都清楚了，下面来分析下`acquireQueued`函数，线程封装成节点后，是如何自旋阻塞等待获取资源的，代码如下：
```java
/**
* @description: 自旋机制等待获取资源
* @param node
* @param arg
* @return: boolean
*/
final boolean acquireQueued(final Node node, int arg) {
//异常状态，默认是
boolean failed = true;
try {
//该线程是否中断过，默认否
boolean interrupted = false;
for (;;) {//自旋
//获取前驱节点
final Node p = node.predecessor();
//如果前驱节点是首节点，获取资源（子类实现）
if (p == head & & tryAcquire(arg)) {
//获取资源成功，设置当前节点为头节点，清空当前节点的信息，把当前节点变成哨兵节点
setHead(node);
//原来首节点下个节点指向为null
p.next = null; // help GC
//非异常状态，
failed = false;
//返回线程中断状态
return interrupted;
}
/**
* 如果前驱节点不是首节点， ，
* 1.如果前驱节点的等待状态是SIGNAL， ， ，
* 2.如果前驱节点的等大状态是CANCELLED， （ ）
* 3.以上两者都不符合， ，
*/
if (shouldParkAfterFailedAcquire(p, node) & &
//使用LockSupport类的静态方法park挂起当前线程， ， ，
parkAndCheckInterrupt())
//该线程被中断过
interrupted = true;
}
} finally {
// 尝试获取资源失败并执行异常，取消请求，将当前节点从队列中移除
if (failed)
cancelAcquire(node);
}
}
```
一图胜千言，核心流程图如下:
#### 独占式释放资源
有获取资源，自然就少不了释放资源，`A Q S`中提供了`release`模板函数来释放资源，模板流程就是线程释放资源成功，唤醒`CLH`队列的第二个线程节点（**首节点的下个节点**），代码如下
```java
/**
* @description: 独占式-释放资源模板函数
* @param arg
* @return: boolean
*/
public final boolean release(int arg) {
if (tryRelease(arg)) {//释放资源成功，
//获取头部线程节点
Node h = head;
if (h != null & & h.waitStatus != 0) //头部线程节点不为null，
//唤醒CHL队列第二个线程节点
unparkSuccessor(h);
return true;
}
return false;
}
private void unparkSuccessor(Node node) {
//获取节点等待状态
int ws = node.waitStatus;
if (ws < 0 )
//cas更新节点状态为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);
}
}
```
`release` 逻辑非常简单，流程图如下：
#### 共享式获取资源
`acquireShared` 是个模板函数，模板流程就是线程获取共享资源，如果获取到资源，线程直接返回，否则进入`CLH`队列，直到获取到资源为止，且整个过程忽略中断的影响，`acquireShared`函数代码如下
```java
/**
* @description: 共享式-获取资源模板函数
* @param arg
* @return: void
*/
public final void acquireShared(int arg) {
/**
* 1.负数表示失败
* 2.0表示成功，但没有剩余可用资源
* 3.正数表示成功且有剩余资源
*/
if (tryAcquireShared(arg) < 0 ) / / 获 取 资 源 失 败 ， tryAcquireShared 子 类 实 现
//自旋阻塞等待获取资源
doAcquireShared(arg);
}
```
`doAcquireShared` 函数与独占式的`acquireQueued`函数逻辑基本一致，唯一的区别就是下图红框部分
- **节点的标记是共享式**
- **获取资源成功，还会唤醒后续资源，因为资源数可能`>0`，代表还有资源可获取，所以需要做后续线程节点的唤醒**
#### 共享式释放资源
`AQS` 中提供了`releaseShared`模板函数来释放资源， ， （
```java
/**
* @description: 共享式-释放资源模板函数
* @param arg
* @return: boolean
*/
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {//释放资源成功，
//唤醒后继节点
doReleaseShared();
return true;
}
return false;
}
private void doReleaseShared() {
for (;;) {
//获取头节点
Node h = head;
if (h != null & & h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {//如果头节点等待状态为SIGNAL
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//更新头节点等待状态为0
continue; // loop to recheck cases
//唤醒头节点下个线程节点
unparkSuccessor(h);
}
//如果后继节点暂时不需要被唤醒，
else if (ws == 0 & &
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue;
}
if (h == head)
break;
}
}
```
与独占式释放资源区别不大，都是唤醒头节点的下个节点。
**什么是AQS？
`AQS` 的全称是 `AbstractQueuedSynchronizer` ，即`抽象队列同步器`。是Java并发工具的基础， ， （ ） （ ） ， ， ，
**核心思想**
- 若请求的共享资源空闲，则将当前请求的线程设置为有效的工作线程，并将共享资源设置为锁定状态
- 若共享资源被占用，则需要阻塞等待唤醒机制保证锁的分配
**工作原理**
**AQS = `同步状态（ ） + `同步队列（ ， ） + `条件队列（ ） **
- **state**：代表共享资源。`volatile` 保证并发读，`CAS` 保证并发写
- **同步队列（ ， ） ： （ ）
- **条件队列（ ） ： ，
**实现原理**
- 通过CLH队列的变体：
- 每个请求资源的线程被包装成一个节点来实现锁的分配
- 通过`volatile`的`int`类型的成员变量`state`表示同步状态
- 通过FIFO队列完成资源获取的排队工作
- 通过CAS完成对`state`的修改
### 共享方式
AQS定义两种资源共享方式。无论是独占锁还是共享锁， ，
**① 独占锁(`Exclusive`)模式**：只能被一个线程获取到(`Reentrantlock`)。
模式.png)
**② 共享锁(`Share`)模式**：可以被多个线程同时获取(`Semaphore/CountDownLatch/ReadWriteLock`)。
模式.png)
### state机制
提供`volatile`变量`state`，用于同步线程之间的共享状态。通过 `CAS` 和 `volatile` 保证其原子性和可见性。核心要点：
- state 用 `volatile` 修饰，保证多线程中的可见性
- `getState()` 和 `setState()` 方法**采用final修饰**，
- `compareAndSetState()` 方法采用乐观锁思想的CAS算法， ，
**state应用案例**：
| 案例 | 描述 |
| ------------------------ | ------------------------------------------------------------ |
| `Semaphore` | 使用AQS同步状态来保存信号量的当前计数。tryRelease会增加计数，
| `CountDownLatch` | 使用AQS同步状态来表示计数。计数为0时， （ ）
| `ReentrantReadWriteLock` | 使用AQS同步状态中的16位保存写锁持有的次数，
| `ThreadPoolExecutor` | Worker利用AQS同步状态实现对独占线程变量的设置（ ）
| `ReentrantLock` | 使用AQS保存锁重复持有的次数。当一个线程获取锁时， ， ，
### 双队列
- **同步队列（ ） ：
- **条件队列（ ） ： ，
**注意**
- 同步队列与条件队列节点可相互转化
- 一个线程只能存在于两个队列中的一个
#### 同步队列
**同步队列是用来管理多个线程的休眠与唤醒**。
同步队列依赖一个双向链表（ ） ， ， ，
结构.png)
如果没有锁竞争，线程可以直接获取到锁，就不会进入同步队列。即没有锁竞争时，同步队列(syncQueue)是空的，当存在锁竞争时，线程会进入到同步队列中。一旦进入到同步队列中，就会有线程切换。标准的 CHL 无锁队列是单向链表，同步队列(syncQueue) 在 CHL 基础上做了改进：
- **同步队列是双向链表**。和二叉树一样，双向链表目前也没有无锁算法的实现。双向链表需要同时设置前驱和后继结点，这两次操作只能保证一个是原子性的
- **node.pre一定可以遍历所有结点， ，
#### 条件队列
**条件队列是类似wait与signal作用， ，
当线程存在于同步队列的头结点时，调用 `await` 方法进行阻塞（ ） `waitQueue` 的操作都是在获取锁的线程中执行，不存在数据竞争的问题。
ConditionObject重要的方法说明：
- **await**：阻塞线程并放弃锁，加入到等待队列中
- **signal**：唤醒等待线程，没有特殊的要求，尽量使用 signalAll
- **addConditionWaiter**：将结点(状态为 CONDITION)添加到等待队列 waitQueue 中，不存在锁竞争
- **fullyRelease**：释放锁，并唤醒后继等待线程
- **isOnSyncQueue**：根据结点是否在同步队列上，判断等待线程是否已经被唤醒
- **acquireQueued**：
- **unlinkCancelledWaiters**：清理取消等待的线程
### 框架架构图
**常见问题**
**问题1： ？
这个问题，关键是修改状态时是否存在数据竞争，如果有则必须使用 compareAndSetState。
- lock.lock() 获取锁时会发生数据竞争，必须使用 CAS 来保障线程安全，也就是 compareAndSetState 方法
- lock.unlock() 释放锁时，线程已经获取到锁，没有数据竞争，也就可以直接使用 setState 修改锁的状态
**问题2： ， ？
- next 域：需要修改二处来保证原子性，一是 tail.next；
- prev 域：只需要修改一处来保证原子性，就是 tail 指针。你可能会说不需要修改 node.prev 吗？当然需要，但 node 还没添加到链表中，其 node.prev 修改并没有锁竞争的问题，将 tail 指针指向 node 时，如果失败会通过自旋不断尝试
**问题3： ， ？
唤醒同步线程时，如果有后继结点，那么时间复杂为 O(1)。否则只能只反向遍历，时间复杂度为 O(n)。以下两种情况，则认为 node.next 不可靠，需要从 tail 反向遍历。
- node.next=null： ，
- node.next.waitStatus>0： ，
## Condition
Condition的作用是对锁进行更精确的控制。Condition中的await()方法相当于Object的wait()方法， ， ， ；
## volatile
Java 语言提供了一种稍弱的同步机制，即 volatile 变量， ，
**volatile特性与原理**
- **可见性**： ， （ ）
- **有序性**：
- **volatile性能**： ， ，
- **内存屏障**： ， ， （ ）
- **轻量级同步机制**： ， ，
- **禁止重排序**：
**使用场景**
- 状态标记量
- DCL（ ）
**CPU缓存**
CPU缓存的出现主要是为了解决CPU运算速度与内存读写速度不匹配的矛盾， ， ：
- **一级缓存**： ， ，
- **二级缓存**： ， ， ，
- **三级缓存**： ，
**volatile的特性**
- 保证了线程可见性，不保证原子性，保证一定的有序性（禁止指令重排序）
- 在JVM底层volatile是采用“内存屏障”来实现的
- volatile常用场景： （ ， ）
- volatile不会引起线程上下文的切换和调度
- 基于lock前缀指令， （ ）
## lambda
### 函数式接口
函数接口是只有一个抽象方法的接口，用作 Lambda 表达式的类型。使用@FunctionalInterface注解修饰的类， ， ， ， ：
| 函数接口 | 抽象方法 | 功能 | 参数 | 返回类型 | 示例 |
| -------------- | --------------- | ---------------------- | ----- | -------- | ------------------- |
| Predicate | test(T t) | 判断真假 | T | boolean | 身高大于185cm吗？
| Consumer | accept(T t) | 消费消息 | T | void | 输出一个值 |
| Function | R apply(T t) | 将T映射为R（ ）
| Supplier | T get() | 生产消息 | None | T | 工厂方法 |
| UnaryOperator | T apply(T t) | 一元操作 | T | T | 逻辑非（!）
| BinaryOperator | apply(T t, U u) | 二元操作 | (T,T) | (T) | 求两个数的乘积（*）
### 常用的流
#### collect
**将流转换为集合。有toList()、toSet()、toMap()等，及早求值**。
```java
public
public
List< Student >
new
System.out.println(studentList);
}
}
// 输出结果
// [Student{name='路飞',
// Student{name='红发',
// Student{name='白胡子',
```
#### filter
顾名思义，起**过滤筛选**的作用。**内部就是Predicate接口。惰性求值。**
```java
public class TestCase {
public static void main(String[] args) {
List< Student > students = new ArrayList< >(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
List< Student > list = students.stream()
.filter(stu -> stu.getStature() < 180 )
.collect(Collectors.toList());
System.out.println(list);
}
}
// 输出结果
// [Student{name='路飞', age=22, stature=175, specialities=null}]
```
#### map
**转换功能，
```java
public class TestCase {
public static void main(String[] args) {
List< Student > students = new ArrayList< >(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
List< String > names = students.stream().map(student -> student.getName())
.collect(Collectors.toList());
System.out.println(names);
}
}
// 输出结果
// [路飞, 红发, 白胡子]
```
例子中将student对象转换为String对象，
#### flatMap
**将多个Stream合并为一个Stream。惰性求值。**
```java
public class TestCase {
public static void main(String[] args) {
List< Student > students = new ArrayList< >(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
List< Student > studentList = Stream.of(students,
asList(new Student("艾斯", 25, 183),
new Student("雷利", 48, 176)))
.flatMap(students1 -> students1.stream()).collect(Collectors.toList());
System.out.println(studentList);
}
}
// 输出结果
// [Student{name='路飞', age=22, stature=175, specialities=null},
// Student{name='红发', age=40, stature=180, specialities=null},
// Student{name='白胡子', age=50, stature=185, specialities=null},
// Student{name='艾斯', age=25, stature=183, specialities=null},
// Student{name='雷利', age=48, stature=176, specialities=null}]
```
调用Stream.of的静态方法将两个list转换为Stream，
#### max和min
我们经常会在集合中**求最大或最小值**，使用流就很方便。**及早求值。**
```java
public class TestCase {
public static void main(String[] args) {
List< Student > students = new ArrayList< >(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
Optional< Student > max = students.stream()
.max(Comparator.comparing(stu -> stu.getAge()));
Optional< Student > min = students.stream()
.min(Comparator.comparing(stu -> stu.getAge()));
//判断是否有值
if (max.isPresent()) {
System.out.println(max.get());
}
if (min.isPresent()) {
System.out.println(min.get());
}
}
}
// 输出结果
// Student{name='白胡子', age=50, stature=185, specialities=null}
// Student{name='路飞', age=22, stature=175, specialities=null}
```
**max、min接收一个Comparator**（ ， ） ， ， ， ； ， ；
#### count
**统计功能， ，
```java
public class TestCase {
public static void main(String[] args) {
List< Student > students = new ArrayList< >(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
long count = students.stream().filter(s1 -> s1.getAge() < 45 ) . count ( ) ;
System.out.println("年龄小于45岁的人数是：
}
}
// 输出结果
// 年龄小于45岁的人数是：
```
#### reduce
**reduce 操作可以实现从一组值中生成一个值**。在上述例子中用到的 count 、 min 和 max 方法，因为常用而被纳入标准库中。事实上，这些方法都是 reduce 操作。**及早求值。**
```java
public class TestCase {
public static void main(String[] args) {
Integer reduce = Stream.of(1, 2, 3, 4).reduce(0, (acc, x) -> acc+ x);
System.out.println(reduce);
}
}
// 输出结果：
```
我们看得reduce接收了一个初始值为0的累加器， ，
### 高级集合类及收集器
#### 转换成值
**收集器，一种通用的、从流生成复杂值的结构。**只要将它传给 collect 方法，所有的流就都可以使用它了。标准类库已经提供了一些有用的收集器，**以下示例代码中的收集器都是从 java.util.stream.Collectors 类中静态导入的。**
```java
public class CollectorsTest {
public static void main(String[] args) {
List< Student > students1 = new ArrayList< >(3);
students1.add(new Student("路飞", 23, 175));
students1.add(new Student("红发", 40, 180));
students1.add(new Student("白胡子", 50, 185));
OutstandingClass ostClass1 = new OutstandingClass("一班", students1);
//复制students1，
List< Student > students2 = new ArrayList< >(students1);
students2.remove(1);
OutstandingClass ostClass2 = new OutstandingClass("二班", students2);
//将ostClass1、ostClass2转换为Stream
Stream< OutstandingClass > classStream = Stream.of(ostClass1, ostClass2);
OutstandingClass outstandingClass = biggestGroup(classStream);
System.out.println("人数最多的班级是：" + outstandingClass.getName());
System.out.println("一班平均年龄是：" + averageNumberOfStudent(students1));
}
/**
* 获取人数最多的班级
*/
private static OutstandingClass biggestGroup(Stream< OutstandingClass > outstandingClasses) {
return outstandingClasses.collect(
maxBy(comparing(ostClass -> ostClass.getStudents().size())))
.orElseGet(OutstandingClass::new);
}
/**
* 计算平均年龄
*/
private static double averageNumberOfStudent(List< Student > students) {
return students.stream().collect(averagingInt(Student::getAge));
}
}
// 输出结果
// 人数最多的班级是：一班
// 一班平均年龄是：
```
maxBy或者minBy就是求最大值与最小值。
#### 转换成块
**常用的流操作是将其分解成两个集合， ，
将示例学生分为会唱歌与不会唱歌的两个集合。
```java
public class PartitioningByTest {
public static void main(String[] args) {
// 省略List< student > students的初始化
Map< Boolean , List < Student > > listMap = students.stream().collect(
Collectors.partitioningBy(student -> student.getSpecialities().
contains(SpecialityEnum.SING)));
}
}
```
#### 数据分组
数据分组是一种更自然的分割数据操作，与将数据分成 ture 和 false 两部分不同，**可以使用任意值对数据分组。Collectors.groupingBy接收一个Function做转换。**
**如图， ， ，
```java
public class GroupingByTest {
public static void main(String[] args) {
//省略List< student > students的初始化
Map< SpecialityEnum , List < Student > > listMap =
students.stream().collect(
Collectors.groupingBy(student -> student.getSpecialities().get(0)));
}
}
```
Collectors.groupingBy与SQL 中的 group by 操作是一样的。
#### 字符串拼接
如果将所有学生的名字拼接起来， ？ ， ，
```java
public class JoiningTest {
public static void main(String[] args) {
List< Student > students = new ArrayList< >(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
String names = students.stream()
.map(Student::getName).collect(Collectors.joining(",","[","]"));
System.out.println(names);
}
}
//输出结果
//[路飞,红发,白胡子]
```
joining接收三个参数， ， ，
## Striped64
Striped64的设计思路是在竞争激烈的时候尽量分散竞争。
**Striping（ ）
大多数磁盘系统都对访问次数（每秒的 I/O 操作， ） （ ， ） ， ， ， ，
条带（ ） ， ，
**Striped64设计**
Striped64通过维护一个原子更新Cell表和一个base字段， ， ， ， ， ， ，
## LongAdder
LongAdder是JDK1.8开始出现的， ， ， ， ， ， ：
LonAdder和AtomicLong性能测试对比：
LongAdder就是基于Striped64实现， ， ， ， ， ， ， ， ， ， ， ，
## Semaphore
Semaphore是一个计数信号量，
**数据结构**
- 和"ReentrantLock"一样， ， ；
- Sync包括两个子类： ； ，
## CyclicBarrier
CyclicBarrier是一个同步辅助类， ，
**比较CountDownLatch和CyclicBarrier**
- CountDownLatch的作用是允许1或N个线程等待其他线程完成执行；
- CountDownLatch的计数器无法被重置； ，
**数据结构**
CyclicBarrier是包含了"ReentrantLock对象lock"和"Condition对象trip"，它是通过独占锁实现的。下面通过源码去分析到底是如何实现的。
## CountDownLatch
CountDownLatch是一个同步辅助类， ，
**CountDownLatch和CyclicBarrier的区别**
- CountDownLatch的作用是允许1或N个线程等待其他线程完成执行；
- CountDownLatch的计数器无法被重置； ，
**数据结构**
CountDownLatch的数据结构很简单， ， ，
## CompletableFuture
CompletableFuture是Java 8新增的一个类， ， ， ， ， ，
**Future的局限性**
- **Future 的结果在非阻塞的情况下，不能执行更进一步的操作**
我们知道， ，
- **不能组合多个Future的结果**
假设你有多个Future异步任务， ， ，
- **多个Future不能组成链式调用**
当异步任务之间有依赖关系时， ，
- **没有异常处理**
**注意事项**
- **CompletableFuture默认线程池是否满足使用**
前面提到创建CompletableFuture异步任务的静态方法runAsync和supplyAsync等， ， ：
```java
private static final Executor asyncPool = useCommonPool ? ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();
```
可以看到， ， ， ， ， ， ， ， ， ，
- **get设置超时时间不能串行get，
**① 创建异步任务**
通常可以使用下面几个CompletableFuture的静态方法创建一个异步任务
```java
// 创建无返回值的异步任务
public static CompletableFuture< Void > runAsync(Runnable runnable);
// 无返回值， （ ）
public static CompletableFuture< Void > runAsync(Runnable runnable, Executor executor);
// 创建有返回值的异步任务
public static < U > CompletableFuture< U > supplyAsync(Supplier< U > supplier);
// 有返回值，可指定线程池
public static < U > CompletableFuture< U > supplyAsync(Supplier< U > supplier, Executor executor);
```
使用示例：
```java
Executor executor = Executors.newFixedThreadPool(10);
CompletableFuture< Void > future = CompletableFuture.runAsync(() -> {
//do something
}, executor);
int poiId = 111;
CompletableFuture< String > future = CompletableFuture.supplyAsync(() -> {
PoiDTO poi = poiService.loadById(poiId);
return poi.getName();
});
// Block and get the result of the Future
String poiName = future.get();
```
**② 使用回调方法**
通过`future.get()`方法获取异步任务的结果，还是会阻塞的等待任务完成
CompletableFuture提供了几个回调方法， ，
```java
// 无参数、无返回值
public CompletableFuture< Void > thenRun(Runnable runnable);
// 接受参数，无返回值
public CompletableFuture< Void > thenAccept(Consumer< ? super T> action);
// 接受参数T，
public < U > CompletableFuture< U > thenApply(Function< ? super T,? extends U> fn);
```
使用示例：
```java
CompletableFuture< Void > future = CompletableFuture.supplyAsync(() -> "Hello")
.thenRun(() -> System.out.println("do other things. 比如异步打印日志或发送消息"));
// 如果只想在一个CompletableFuture任务执行完后， ， ，
// 如果主线程不依赖thenRun中的代码执行完成，
CompletableFuture< Void > future = CompletableFuture.supplyAsync(() -> "Hello")
.thenAccept((s) -> System.out.println(s + " world"));
// 输出：
// 回调方法希望使用异步任务的结果， ，
CompletableFuture< Boolean > future = CompletableFuture.supplyAsync(() -> {
PoiDTO poi = poiService.loadById(poiId);
return poi.getMainCategory();
}).thenApply((s) -> isMainPoi(s)); // boolean isMainPoi(int poiId);
future.get();
// 希望将异步任务的结果做进一步处理， ，
// 如果主线程要获取回调方法的返回，
```
**③ 组合两个异步任务**
```java
// thenCompose方法中的异步任务依赖调用该方法的异步任务
public < U > CompletableFuture< U > thenCompose(Function< ? super T, ? extends CompletionStage< U > > fn);
// 用于两个独立的异步任务都完成的时候
public < U , V > CompletableFuture< V > thenCombine(CompletionStage< ? extends U> other, BiFunction< ? super T,? super U,? extends V> fn);
```
使用示例：
```java
CompletableFuture< List < Integer > > poiFuture = CompletableFuture.supplyAsync(
() -> poiService.queryPoiIds(cityId, poiId)
);
// 第二个任务是返回CompletableFuture的异步方法
CompletableFuture< List < DealGroupDTO > > getDeal(List< Integer > poiIds){
return CompletableFuture.supplyAsync(() -> poiService.queryPoiIds(poiIds));
}
// thenCompose
CompletableFuture< List < DealGroupDTO > > resultFuture = poiFuture.thenCompose(poiIds -> getDeal(poiIds));
resultFuture.get();
```
thenCompose和thenApply的功能类似， < U > `的Function， < U > `中直接获取结果U时， ， < CompletableFuture < List < DealGroupDTO > >>`，而不是`CompletableFuture< List < DealGroupDTO > >`
```java
CompletableFuture< String > future = CompletableFuture.supplyAsync(() -> "Hello")
.thenCombine(CompletableFuture.supplyAsync(() -> "world"), (s1, s2) -> s1 + s2);
// future.get()
```
**④ 组合多个CompletableFuture**
当需要多个异步任务都完成时，再进行后续处理，可以使用**allOf**方法：
```java
CompletableFuture< Void > poiIDTOFuture = CompletableFuture
.supplyAsync(() -> poiService.loadPoi(poiId))
.thenAccept(poi -> {
model.setModelTitle(poi.getShopName());
// do more thing
});
CompletableFuture< Void > productFuture = CompletableFuture
.supplyAsync(() -> productService.findAllByPoiIdOrderByUpdateTimeDesc(poiId))
.thenAccept(list -> {
model.setDefaultCount(list.size());
model.setMoreDesc("more");
});
// future3等更多异步任务，
// allOf组合所有异步任务，
CompletableFuture.allOf(poiIDTOFuture, productFuture, future3, ...).join();
```
该方法挺适合C端的业务， ， ， ， ，
```java
CompletableFuture< String > future1 = CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
throw new IllegalStateException(e);
}
return "Result of Future 1";
});
CompletableFuture< String > future2 = CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new IllegalStateException(e);
}
return "Result of Future 2";
});
CompletableFuture< String > future3 = CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
throw new IllegalStateException(e);
return "Result of Future 3";
});
CompletableFuture< Object > anyOfFuture = CompletableFuture.anyOf(future1, future2, future3);
System.out.println(anyOfFuture.get()); // Result of Future 2
```
**⑤ 异常处理**
```java
Integer age = -1;
CompletableFuture< Void > maturityFuture = CompletableFuture.supplyAsync(() -> {
if(age < 0 ) {
throw new IllegalArgumentException("Age can not be negative");
}
if(age > 18) {
return "Adult";
} else {
return "Child";
}
}).exceptionally(ex -> {
System.out.println("Oops! We have an exception - " + ex.getMessage());
return "Unknown!";
}).thenAccept(s -> System.out.print(s));
// Unkown!
```
exceptionally方法可以处理异步任务的异常， ， ， ， ：
```java
Integer age = -1;
CompletableFuture< String > maturityFuture = CompletableFuture.supplyAsync(() -> {
if(age < 0 ) {
throw new IllegalArgumentException("Age can not be negative");
}
if(age > 18) {
return "Adult";
} else {
return "Child";
}
}).handle((res, ex) -> {
if(ex != null) {
System.out.println("Oops! We have an exception - " + ex.getMessage());
return "Unknown!";
}
return res;
});
```
**⑥ 分片处理**
分片和并行处理： ， ， （ ） ， ：
```java
// 请求商品数量过多时，做分批异步处理
List< List < Long > > skuBaseIdsList = ListUtils.partition(skuIdList, 10);//分片
// 并行
List< CompletableFuture < List < SkuSales > >> futureList = Lists.newArrayList();
for (List< Long > skuId : skuBaseIdsList) {
CompletableFuture< List < SkuSales > > tmpFuture = getSkuSales(skuId);
futureList.add(tmpFuture);
}
// 聚合
futureList.stream().map(CompletalbleFuture::join).collent(Collectors.toList());
```
**⑦ 应用案例**
首先还是需要先完成分工方案， ， ：
- 任务1负责洗水壶、烧开水
- 任务2负责洗茶壶、洗茶杯和拿茶叶
- 任务3负责泡茶。其中任务3要等待任务1和任务2都完成后才能开始
```java
// 任务1：
CompletableFuture f1 =
CompletableFuture.runAsync(()->{
System.out.println("T1:洗水壶...");
sleep(1, TimeUnit.SECONDS);
System.out.println("T1:烧开水...");
sleep(15, TimeUnit.SECONDS);
});
// 任务2：
CompletableFuture f2 =
CompletableFuture.supplyAsync(()->{
System.out.println("T2:洗茶壶...");
sleep(1, TimeUnit.SECONDS);
System.out.println("T2:洗茶杯...");
sleep(2, TimeUnit.SECONDS);
System.out.println("T2:拿茶叶...");
sleep(1, TimeUnit.SECONDS);
return "龙井";
});
// 任务3： ：
CompletableFuture f3 =
f1.thenCombine(f2, (__, tf)->{
System.out.println("T3:拿到茶叶:" + tf);
System.out.println("T3:泡茶...");
return "上茶:" + tf;
});
// 等待任务3执行结果
System.out.println(f3.join());
void sleep(int t, TimeUnit u) {
try {
u.sleep(t);
}catch(InterruptedException e){}
}
// 一次执行结果：
T1:洗水壶...
T2:洗茶壶...
T1:烧开水...
T2:洗茶杯...
T2:拿茶叶...
T3:拿到茶叶:龙井
T3:泡茶...
上茶:龙井
```
# 集合
## List
### ArrayList(数组)
ArrayList 是一个**数组队列**，相当于 ** 动态数组**。与Java中的数组相比，
它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要将已经有数组的数据复制到新的存储空间中。当从 ArrayList 的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
### LinkedList(链表)
LinkedList 是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了 List 接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。
- LinkedList是有序的双向链表
- LinkedList在内存中开辟的内存不连续【ArrayList开辟的内存是连续的】
- LinkedList插入和删除元素很快，
### Vector(数组实现、线程同步)
Vector 与 ArrayList 一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写 Vector， ， ， ，
### CopyOnWriteArrayList
**Copy-On-Write是什么？
顾名思义，在计算机中就是当你想要对一块内存进行修改时，我们不在原有内存块中进行`写`操作，而是将内存拷贝一份，在新的内存中进行`写`操作，`写`完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉。
CopyOnWriteArrayList相当于线程安全的ArrayList， ， ， ， ， ：
- 最适合于具有以下特征的应用： ， ，
- 它是线程安全的
- 因为通常需要复制整个基础数组， （
- 迭代器支持hasNext(), next()等不可变操作，但不支持可变 remove()等操作
- 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照
**CopyOnWriteArrayList数据结构**
- CopyOnWriteArrayList实现了List接口，
- CopyOnWriteArrayList包含了成员lock。每一个CopyOnWriteArrayList都和一个互斥锁lock绑定， ，
- CopyOnWriteArrayList包含了成员array数组，
**CopyOnWriteArrayList原理**
下面从“动态数组”和“线程安全”两个方面进一步对CopyOnWriteArrayList的原理进行说明。
- **CopyOnWriteArrayList的“动态数组”机制**
它内部有个“volatile数组”(array)来保持数据。
在“添加/修改/删除”数据时， ， ， ， ， ， ，
低。但是单单只是进行遍历查找的话，效率比较高
- **CopyOnWriteArrayList的“线程安全”机制**
是通过volatile和互斥锁来实现的。
- **CopyOnWriteArrayList是通过“volatile数组”来保存数据的**。一个线程读取volatile数组时， ，
- **CopyOnWriteArrayList通过互斥锁来保护数据**。在“添加、修改、删除”数据时， ， ， ， ； ，
## Set
### HashSet(Hash表)
**HashSet 基于 HashMap， ， ， ， ， ， ，
### TreeSet(二叉树)
底层通过TreeMap来实现， ， （ （ ） ） ， （ ） （ ） （ ， ）
- TreeSet()是使用二叉树的原理对新 add()的对象按照指定的顺序排序（升序、降序），每增加一个对象都会进行排序，将对象插入的二叉树指定的位置
- Integer 和 String 对象都可以进行默认的 TreeSet 排序，而自定义类的对象是不可以的，自己定义的类必须实现 Comparable 接口，并且覆写相应的 compareTo()函数，才可以正常使用
- 在覆写 compare()函数时，要返回相应的值才能使 TreeSet 按照一定的规则来排序
- 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数
### LinkedHashSet
对于 LinkedHashSet 而言，它继承与 HashSet、又基于 LinkedHashMap 来实现的。LinkedHashSet 底层使用LinkedHashMap 来保存所有元素，它继承与 HashSet，
### ConcurrentSkipListSet
ConcurrentSkipListSet是线程安全的有序的集合(相当于线程安全的TreeSet)； ， ，
### CopyOnWriteArraySet
CopyOnWriteArraySet是线程安全的无序的集合， ，
- **通过“动态数组(CopyOnWriteArrayList)”实现（
- **线程安全是通过volatile和互斥锁来实现**
- **无序的不能重复集合**
**CopyOnWriteArraySet特性**
- 它最适合于具有以下特征的应用程序：
- 它是线程安全的
- 因为通常需要复制整个基础数组， （
- 迭代器支持hasNext(), next()等不可变操作，但不支持可变 remove()等 操作
- 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照
**数据结构**
- CopyOnWriteArraySet继承于AbstractSet，
- CopyOnWriteArraySet包含CopyOnWriteArrayList对象， ， ！ ； ， ， ， ， ，
### ConcurrentSkipListSet
ConcurrentSkipListSet是线程安全的有序的集合， ， ， ， ， ， ， ，
**数据结构**
- ConcurrentSkipListSet继承于AbstractSet。因此，
- ConcurrentSkipListSet实现了NavigableSet接口。因此，
- ConcurrentSkipListSet是通过ConcurrentSkipListMap实现的。它包含一个ConcurrentNavigableMap对象m， ； ，
## Map
### HashMap(数组+链表+红黑树)
**工作原理**
**HashMap（ ， ， ，
hashCode 是定位的，**存储位置**； ，
**put()**
- 第一步：调用 hash(K) 方法**计算 K 的 hash 值**，然后结合数组长度，计算得数组下标
- 第二步：**调整数组大小**（当容器中的元素个数大于 capacity * loadfactor 时， ）
- 第三步：
- 如果 **K 的 hash 值** 在 HashMap 中**不存在**，则执行**插入**，若存在，则发生**碰撞**
- 如果 K 的 hash 值在 HashMap 中**存在**，且它们两者 **equals 返回 true** ，则**更新键值对**
- 如果 K 的 hash 值在 HashMap 中**存在**，且它们两者 **equals 返回 false** ，则**插入链表的尾部（尾插法）或者红黑树中（树的添加方式）**
**get()**
- 第一步：调用 hash(K) 方法（**计算 K 的 hash 值**）从而**获取该键值所在链表的数组下标**
- 第二步： ，
大方向上， ， ：
- capacity： ， ， ，
- loadFactor： ，
- threshold： ，
Java8 对 HashMap 进行了一些修改，最大的不同就是利用了红黑树，所以其由 数组+链表+红黑树 组成。根据 Java7 HashMap 的介绍，我们知道，查找的时候，根据 hash 值我们能够快速定位到数组的具体下标，但是之后的话，需要顺着链表一个个比较下去才能找到我们需要的，时间复杂度取决于链表的长度，为 O(n)。为了降低这部分的开销，在 Java8 中，当链表中的元素超过了 8 个以后，会将链表转换为红黑树，在这些位置进行查找的时候可以降低时间复杂度为 O(logN)。
HashMap具有如下特性：
- HashMap 的存取是没有顺序的
- KV 均允许为 NULL
- 多线程情况下该类不安全，可以考虑用 HashTable
- JDk8底层是数组 + 链表 + 红黑树，
- 初始容量和装载因子是决定整个类性能的关键点，轻易不要动
- HashMap是**懒汉式**创建的，
- 单向链表转换为红黑树的时候会先变化为**双向链表**最终转换为**红黑树**，切记双向链表跟红黑树是`共存`的
- 对于传入的两个`key`，会强制性的判别出个高低，目的是为了决定向左还是向右放置数据
- 链表转红黑树后会努力将红黑树的`root`节点和链表的头节点 跟`table[i]`节点融合成一个
- 在删除时候是先判断删除节点红黑树个数是否需要转链表，不转链表就跟`RBT`类似，找个合适的节点来填充已删除的节点
- 红黑树的`root`节点`不一定`跟`table[i]`也就是链表的头节点是同一个，三者同步是靠`MoveRootToFront`实现的。而`HashIterator.remove()`会在调用`removeNode`的时候`movable=false`
### TreeMap(可排序)
TreeMap 实现 SortedMap 接口，能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用 Iterator 遍历 TreeMap 时，得到的记录是排过序的。如果使用排序的映射，建议使用 TreeMap。在使用 TreeMap 时， ，
### HashTable(线程安全)
Hashtable 是遗留类，很多映射的常用功能与 HashMap 类似，不同的是它承自 Dictionary 类，并且是线程安全的，任一时间只有一个线程能写 Hashtable， ，
### LinkedHashMap(记录插入顺序)
LinkedHashMap 是 HashMap 的一个子类，保存了记录的插入顺序，在用 Iterator 遍历LinkedHashMap 时，先得到的记录肯定是先插入的，也可以在构造时带参数，按照访问次序排序。
**如何实现LRUCache？
LRU（ ） `accessOrder＝ 基于访问顺序 ）再加上对 LinkedHashMap 的`数据操作上锁`实现的缓存策略。
- `LruCache` 是通过`LinkedHashMap`构造方法的第三个参数的`accessOrder=true`实现了`LinkedHashMap`的数据排序基于访问顺序 （ ） ， ， ，
- 然后在每次 `LruCache.get(K key)` 方法里都会调用`LinkedHashMap.get(Object key)`
- 如上述设置了 `accessOrder=true` 后，每次 `LinkedHashMap.get(Object key)` 都会进行 `LinkedHashMap.makeTail(LinkedEntry<K, V> e)`
- LinkedHashMap 是`双向循环链表`，然后每次 `LruCache.get -> LinkedHashMap.get` 的数据就被放到最末尾了
- 在 put 和 `trimToSize` 的方法执行下，如果发生数据量移除，会优先移除掉最前面的数据（因为最新访问的数据在尾部）
- LruCache 在内部的get、put、remove包括 trimToSize 都是安全的（因为都上锁了）
- LruCache 自身并没有释放内存， ， ， ，
- 覆写entryRemoved方法能知道 LruCache 数据移除时是否发生了冲突，也可以去手动释放资源
- maxSize 和 sizeOf(K key, V value) 方法的覆写息息相关，必须相同单位。（ 比如 maxSize 是7MB， ）
#### LruCache的唯一构造方法
```java
/**
* LruCache的构造方法：
*/
public LruCache(int maxSize) {
...
this.maxSize = maxSize;
/*
* 初始化LinkedHashMap
* 第一个参数： ，
* 第二个参数： ， ，
* 第三个参数：
*/
this.map = new LinkedHashMap< K , V > (0, 0.75f, true);
}
```
#### LruCache.get(K key)
下述的 get 方法表面并没有看出哪里有实现了 LRU 的缓存策略。主要在 mapValue = map.get(key);里，调用了 LinkedHashMap 的 get 方法，再加上 LruCache 构造里默认设置 LinkedHashMap 的 accessOrder=true。
```java
/**
* 根据 key 查询缓存，如果存在于缓存或者被 create 方法创建了。
* 如果值返回了，那么它将被移动到双向循环链表的的尾部。
* 如果如果没有缓存的值，则返回 null。
*/
public final V get(K key) {
...
V mapValue;
synchronized (this) {
// 关键点：
mapValue = map.get(key);
// 计算 命中次数
if (mapValue != null) {
hitCount++;
return mapValue;
}
// 计算 丢失次数
missCount++;
}
/*
* 官方解释：
* 尝试创建一个值， ，
* 候， ， ，
*/
V createdValue = create(key);
if (createdValue == null) {
return null;
}
/***************************
* 不覆写create方法走不到下面 *
** *************************/
/*
* 正常情况走不到这里
* 走到这里的话 说明 实现了自定义的 create(K key) 逻辑
* 因为默认的 create(K key) 逻辑为null
*/
synchronized (this) {
// 记录 create 的次数
createCount++;
// 将自定义create创建的值， ， ，
mapValue = map.put(key, createdValue);
// 如果之前存在相同key的value，
if (mapValue != null) {
/*
* 有冲突
* 所以 撤销 刚才的 操作
* 将 之前相同key 的值 重新放回去
*/
map.put(key, mapValue);
} else {
// 拿到键值对，计算出在容量中的相对长度，然后加上
size += safeSizeOf(key, createdValue);
}
}
// 如果上面 判断出了 将要放入的值发生冲突
if (mapValue != null) {
/*
* 刚才create的值被删除了，
* 告诉 自定义 的 entryRemoved 方法
*/
entryRemoved(false, key, createdValue, mapValue);
return mapValue;
} else {
// 上面 进行了 size += 操作 所以这里要重整长度
trimToSize(maxSize);
return createdValue;
}
}
```
#### LinkedHashMap.get(Object key)
主要看`if (accessOrder)`逻辑即可，如果`accessOrder=true`那么每次get都会执行N次 `makeTail(LinkedEntry<K, V> e)` 。多了一步mainTail动作， ，
```java
/**
* Returns the value of the mapping with the specified key.
*
* @param key the key.
* @return the value of the mapping with the specified key, or {@code null} if no mapping for the specified key is found.
*/
@Override
public V get(Object key) {
/*
* This method is overridden to eliminate the need for a polymorphic
* invocation in superclass at the expense of code duplication.
*/
if (key == null) {
HashMapEntry< K , V > e = entryForNullKey;
if (e == null)
return null;
if (accessOrder)
makeTail((LinkedEntry< K , V > ) e); //把访问的节点迁移到链表的尾部
return e.value;
}
int hash = Collections.secondaryHash(key);
HashMapEntry< K , V > [] tab = table;
for (HashMapEntry< K , V > e = tab[hash & (tab.length - 1)]; e != null; e = e.next) { //从数组中获取
K eKey = e.key;
if (eKey == key || (e.hash == hash & & key.equals(eKey))) {
if (accessOrder)
makeTail((LinkedEntry< K , V > ) e); //把访问的节点迁移到链表尾部。
return e.value;
}
}
return null;
}
/**
* Relinks the given entry to the tail of the list. Under access ordering,
* this method is invoked whenever the value of a pre-existing entry is
* read by Map.get or modified by Map.put.
*/
private void makeTail(LinkedEntry< K , V > e) {
// Unlink e 在链表中删除该节点e
e.prv.nxt = e.nxt;
e.nxt.prv = e.prv;
// Relink e as tail 在尾部添加
LinkedEntry< K , V > header = this.header;
LinkedEntry< K , V > oldTail = header.prv;
e.nxt = header;
e.prv = oldTail;
oldTail.nxt = header.prv = e;
modCount++;
}
```
#### LruCache.put(K key, V value)
```java
public final V put(K key, V value) {
...
synchronized (this) {
...
// 拿到键值对，计算出在容量中的相对长度，然后加上
size += safeSizeOf(key, value);
...
}
...
trimToSize(maxSize);
return previous;
}
```
注意：
- `put` 开始的时候确实是把值放入 `LinkedHashMap` 了，不管超不超过你设定的缓存容量
- 然后根据 `safeSizeOf` 方法计算 此次添加数据的容量是多少，并且加到 `size` 里
- 说到 `safeSizeOf` 就要讲到 `sizeOf(K key, V value)` 会计算出此次添加数据的大小
- 直到 `put` 要结束时，进行了 `trimToSize` 才判断 `size` 是否 大于 `maxSize` 然后进行最近很少访问数据的移除
#### LruCache.trimToSize(int maxSize)
会判断之前 `size` 是否大于 `maxSize` 。是的话，直接跳出后什么也不做。不是的话，证明已经溢出容量了。由 `makeTail` 图已知，最近经常访问的数据在最末尾。拿到一个存放 key 的 Set， ， ，
```java
public void trimToSize(int maxSize) {
/*
* 这是一个死循环，
* 1.只有 扩容 的情况下能立即跳出
* 2.非扩容的情况下， ， ，
*/
while (true) {
K key;
V value;
synchronized (this) {
// 在重新调整容量大小前，本身容量就为空的话，会出异常的。
if (size < 0 | | ( map . isEmpty ( ) & & size ! = 0 ) ) {
throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!");
}
// 如果是 扩容 或者 map为空了， ，
if (size < = maxSize || map.isEmpty()) {
break;
}
Map.Entry< K , V > toEvict = map.entrySet().iterator().next();
key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key);
// 拿到键值对，计算出在容量中的相对长度，然后减去。
size -= safeSizeOf(key, value);
// 添加一次收回次数
evictionCount++;
}
/*
* 将最后一次删除的最少访问数据回调出去
*/
entryRemoved(true, key, value, null);
}
}
```
### ConcurrentHashMap
ConcurrentHashMap是线程安全的哈希表(相当于线程安全的HashMap)； ， ，
**Segment** ** 段**
ConcurrentHashMap 和 HashMap 思路是差不多的， ， ， ， ， ，
**线程安全（ ）
简单理解就是， ， ，
**并行度（ ）
concurrencyLevel： ， ， ， ， ， ，
**Java8** ** 实现 （引入了红黑树）**
Java8 对 ConcurrentHashMap 进行了比较大的改动,Java8 也引入了红黑树。
**ConcurrentHashMap并发**
- **减小锁粒度**
- **ConcurrentHashMap 分段锁（ ）
**ConcurrentHashMap在1.7和1.8的区别**
- **整体结构**
- 1.7：
- 1.8： ， ，
- **put（ ）
- 1.7： ， ， ， ， ，
1. 定位Segment： `rehash值的高位` 和 `segments数组大小-1` 相与得到在 segments中的位置
2. 定位桶：然后在通过 `key的rehash值` 和 `table数组大小-1` 相与得到在table中的位置
- 1.8： ， `rehash值` 直接定位到桶， `首节点first` 后进行判断：
1. 如果为 `null` ，通过 `CAS` 的方式把 value put进去
2. 如果 `非null` ，并且 `first.hash == -1` ，说明其他线程在扩容，参与一起扩容
3. 如果 `非null` ，并且 `first.hash != -1` ， ， ，
- **get（ ）
- 1.7和1.8基本类似， ， ，
- **resize（ ）
- 1.7： ， ， （ ） ，
- 1.8： ， （ ） ， ， ， ，
- **size（ ）
- 1.7：很经典的思路
1. 先采用不加锁的方式，计算两次，如果两次结果一样，说明是正确的，返回
2. 如果两次结果不一样，则把所有 segment 锁住，重新计算所有 segment的 `Count` 的和
- 1.8： ， `baseCount` 变量来记录ConcurrentHashMap 当前 `节点的个数` 。
1. 先尝试通过CAS 修改 `baseCount`
2. 如果多线程竞争激烈， ， `CELLSBUSY` 置1， `baseCount变化的次数` 暂存到一个数组 `counterCells` 里，后续数组 `counterCells` 的值会加到 `baseCount` 中
3. 如果 `CELLSBUSY` 置1失败又会反复进行CAS`baseCount` 和 CAS`counterCells`数组
### ConcurrentSkipListMap
ConcurrentSkipListMap是线程安全的有序的哈希表(相当于线程安全的TreeMap)。它继承于AbstractMap类， ，
**数据结构**
ConcurrentSkipListMap是线程安全的有序的哈希表， ， ， ， ， ， ， ，
# Queue
**Queue（ ） ， （ ） ， （ ） ，
每个元素总是从队列的rear端进入队列， ， ， （ ） ：
图中我们可以看到， ， ：
- **add(E e)：增加元素**
- **remove(Object o)：删除元素**
- **clear()：清除集合中所有元素**
- **size()：集合元素的大小**
- **isEmpty()：集合是否没有元素**
- **contains(Object o)：
## 队列
### Queue
Queue： ， ，
**插入方法**
- **add(E e)**： ， ，
- **offer(E e)**： ， ，
add和offer作为插入方法的唯一不同就在于队列满了之后的处理方式。add抛出异常，
**删除和获取元素方法（和插入方法类似）**
- **remove()**： ， ， ，
- **poll()**： ， ，
- **element()**： ， ， ，
- **peek()**： ， ，
如果队列是空， ， ， ， ， ，
### Deque
Deque在Queue的基础上， ：
- **addFirst(E e)**： ，
- **addLast(E e)**： ，
- **offerFirst(E e)**： ，
- **offerLast(E e)**： ，
- **removeFirst()**： ，
- **removeLast()**： ，
- **pollFirst()**： ，
- **pollLast()**： ，
- **getFirst()**： ，
- **getLast()**： ，
- **peekFirst()**： ，
- **peekLast()**： ，
- **removeFirstOccurrence(Object o)**：
- **removeLastOccurrence(Object o)**：
- **push(E e)**：
- **pop()**：
其实很多方法的效果都是一样的， ，
## 阻塞队列
### BlockingQueue
**BlockingQueue（ ） ，
先给出BlockingQueue新增的方法：
- put(E e)：向队尾插入元素。如果队列满了，阻塞等待，直到被中断为止。
- boolean offer(E e, long timeout, TimeUnit unit)： ， ， ，
- take()：获取并移除队首的元素。如果队列为空，阻塞等待，直到被中断为止。
- poll(long timeout, TimeUnit unit)： ， ， ，
- remainingCapacity()： （ ） ， ，
- drainTo(Collection< ? super E> c)：移除此队列中所有可用的元素，并将它们添加到给定 collection 中。
- drainTo(Collection< ? super E> c, int maxElements)：最多从此队列中移除给定数量的可用元素，并将这些元素添加到给定 collection 中。
**BlockingQueue**最重要的也就是关于阻塞等待的几个方法，而这几个方法正好可以用来实现**生产-消费的模型**。
从图中我们可以知道实现了BlockingQueue的类有以下几个：
- ArrayBlockingQueue：
- LinkedBlockingQueue：
- PriorityBlockingQueue：
- SynchronousQueue：
- DelayQueue：
#### ArrayBlockingQueue
**ArrayBlockingQueue是一个用数组实现的有界阻塞队列**。此队列按照先进先出（ ） ， ， ， ， ， ， ，
**特性**
- **内部使用循环数组进行存储**
- **内部使用ReentrantLock来保证线程安全**
- **由Condition的await和signal来实现等待唤醒功能**
- **支持对生产者线程和消费者线程进行公平的调度**。默认情况下是不保证公平性的。公平性通常会降低吞吐量，但是减少了可变性和避免了线程饥饿问题
**数据结构 —— 数组**
通常， ， ， ， ， ，
**数据结构 —— 环型结构**
为了解决这个问题， ， ， ， ：
我们可以使用两个指针， ，
**入队方法**
ArrayBlockingQueue 提供了多种入队操作的实现来满足不同情况下的需求，入队操作有如下几种：
- **boolean add(E e)**： ， ，
- **void put(E e)**： ， ，
- **boolean offer(E e)**： ， ，
**enqueue** ： ， ，
- **boolean offer(E e, long timeout, TimeUnit unit)**：
**出队方法**
ArrayBlockingQueue提供了多种出队操作的实现来满足不同情况下的需求， ：
- **E poll()**： ， ，
**dequeue** ： ， ， ， ，
- **E poll(long timeout, TimeUnit unit)**： ， ， ，
- **E take()**：
**获取元素方法**
- **peek()**：这里获取元素时上锁是为了避免脏数据的产生
**删除元素方法**
- **remove(Object o)**： ， ， ：
- 当removeIndex == takeIndex时就不需要后面的元素整体往前移了， （ ）
- 当removeIndex != takeIndex时，
#### LinkedBlockingQueue
**LinkedBlockingQueue是一个用链表实现的有界阻塞队列**。此队列的默认和最大长度为`Integer.MAX_VALUE`，也就是无界队列，所以为了避免队列过大造成机器负载或者内存爆满的情况出现，我们在使用的时候建议手动传一个队列的大小。此队列按照先进先出的原则对元素进行排序。
LinkedBlockingQueue是一个阻塞队列， ，
**LinkedBlockingQueue和ArrayBlockingQueue的不同点**
- 队列大小有所不同， ，
- 数据存储容器不同， ，
- 由于ArrayBlockingQueue采用的是数组的存储容器， ， ，
- 两者的实现队列添加或移除的锁不一样， ， ， ， ， ， ， ，
**入队方法**
LinkedBlockingQueue提供了多种入队操作的实现来满足不同情况下的需求， ：
- **void put(E e)**：
- 队列已满，阻塞等待
- 队列未满， ， ， ，
- **boolean offer(E e)**： ， ， ，
- **boolean offer(E e, long timeout, TimeUnit unit)**： ， ？ ， ， ，
**出队方法**
入队列的方法说完后， ， ：
- **E take()**：
- 队列为空，阻塞等待
- 队列不为空，从队首获取并移除一个元素，如果消费后还有元素在队列中，继续唤醒下一个消费线程进行元素移除。如果放之前队列是满元素的情况，移除完后要唤醒生产线程进行添加元素
- **E poll()**：
- **E poll(long timeout, TimeUnit unit)**：
**获取元素方法**
- **peek()**： ， ， ，
**删除元素方法**
- **remove(Object o)**： （ ） ， ， ，
#### PriorityBlockingQueue
**PriorityBlockingQueue是一个支持优先级的无界队列**。默认情况下元素采取自然顺序排列，
#### SynchronousQueue
**SynchronousQueue是一个不存储元素的阻塞队列**。每一个put操作必须等待一个take操作， ， ， ， ，
#### DelayQueue
**DelayQueue是一个支持延时获取元素的无界阻塞队列**。队列使用PriorityQueue来实现。队列中的元素必须实现Delayed接口， ：
- 缓存系统的设计： ， ， ，
- 定时任务调度。使用DelayQueue保存当天将会执行的任务和执行时间， ，
### BlockingDeque
**BlockingDeque（ ） ， ：
- putFirst(E e)：在队首插入元素，如果队列满了，阻塞等待，直到被中断为止。
- putLast(E e)：在队尾插入元素，如果队列满了，阻塞等待，直到被中断为止。
- offerFirst(E e, long timeout, TimeUnit unit)： ， ， ，
- offerLast(E e, long timeout, TimeUnit unit)： ， ， ，
- takeFirst()：获取并移除队首的元素。如果队列为空，阻塞等待，直到被中断为止。
- takeLast()：获取并移除队尾的元素。如果队列为空，阻塞等待，直到被中断为止。
- pollFirst(long timeout, TimeUnit unit)： ， ， ，
- pollLast(long timeout, TimeUnit unit)： ， ， ，
- removeFirstOccurrence(Object o)：
- removeLastOccurrence(Object o)：
#### LinkedBlockingDeque
**LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列**，即可以从队列的两端插入和移除元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。`LinkedBlockingDeque`是可选容量的，在初始化时可以设置容量防止其过度膨胀，如果不设置，默认容量大小为`Integer.MAX_VALUE`。
相比于其它阻塞队列， ， ， ，
**LinkedBlockingDeque和LinkedBlockingQueue的相同点**
- 基于链表
- 容量可选， ，
**LinkedBlockingDeque和LinkedBlockingQueue的不同点**
- 双端链表和单链表
- 不存在头节点
- 一把锁+两个条件
**入队方法**
LinkedBlockingDeque提供了多种入队操作的实现来满足不同情况下的需求， ：
- add(E e)、addFirst(E e)、addLast(E e)
- offer(E e)、offerFirst(E e)、offerLast(E e)
- offer(E e, long timeout, TimeUnit unit)、offerFirst(E e, long timeout, TimeUnit unit)、offerLast(E e, long timeout, TimeUnit unit)
- put(E e)、putFirst(E e)、putLast(E e)
**出队方法**
入队列的方法说完后， ， ：
- **remove()、removeFirst()、removeLast()**
- **poll()、pollFirst()、pollLast()**
- **take()、takeFirst()、takeLast()**
- **poll(long timeout, TimeUnit unit)、pollFirst(long timeout, TimeUnit unit)、pollLast(long timeout, TimeUnit unit)**
**获取元素方法**
获取元素前加锁，
- **element()**
- **peek()**
**删除元素方法**
删除元素是从头/尾向两边进行遍历比较， ， ， ，
- **remove(Object o)**：
### TransferQueue
TransferQueue是JDK 1.7对于并发类库新增加的一个接口， ，
TransferQueue对比与BlockingQueue更强大的一点是， （ ） ， ， （ ）
该接口提供的标准方法：
- tryTransfer(E e)： （ ； ， ，
- transfer(E e)：若当前存在一个正在等待获取的消费者线程，即立刻移交之；**否则， ， ，
- tryTransfer(E e, long timeout, TimeUnit unit)：若当前存在一个正在等待获取的消费者线程，会立即传输给它;**否则将插入元素e到队列尾部， ； ， ，
- hasWaitingConsumer()：判断是否存在消费者线程
- getWaitingConsumerCount()：获取所有等待获取元素的消费线程数量
#### LinkedTransferQueue
LinkedTransferQueue 是**单向链表结构的无界阻塞队列**。
LinkedTransferQueue(LTQ) 相比 BlockingQueue 更进一步，**生产者会一直阻塞直到所添加到队列的元素被某一个消费者所消费（不仅仅是添加到队列里就完事）**。新添加的 transfer 方法用来实现这种约束。顾名思义，阻塞就是发生在元素从一个线程 transfer 到另一个线程的过程中，它有效地实现了元素在线程之间的传递（以建立 Java 内存模型中的 happens-before 关系的方式）。**Doug Lea 说从功能角度来讲， （ ）
# Thread
**什么是进程 ？
进程是**资源分配的最小单位**。（资源包括各种表格、内存空间、磁盘空间） 同一进程中的多条线程将共享该进程中的全部系统资源。
**什么是线程 ？
线程是**CPU调度的最小单位**。线程只由相关堆栈（系统栈或用户栈）寄存器和线程控制表组成。 而寄存器可被用来存储线程内的局部变量。
**什么是并行和并发 ？
- **并行运行**： ×
- **并发运行**：总线程数>CPU数量× （ ： ）
**线程优缺点**
- **优点**
- 创建一个新线程的代价要比创建一个新进程小的多
- 线程之间的切换相较于进程之间的切换需要操作系统做的工作很少
- 线程占用的资源要比进程少很多
- 能充分利用多处理器的可并行数量
- 等待慢速IO操作结束以后，
- 计算（ ） ， ，
- IO密集型应用， ， ，
- **缺点**
- 性能损失
- 健壮性降低
- 缺乏访问控制
- 编程难度提高
## 线程实现方式
**实现线程**只有一种方式：
- **new Thread()**
**实现线程执行内容**有两种方式：
- **继续Thread类**：
- **实现Runable接口**： ，
更多实现线程执行内容的方式，只需在此基础上进行封装：
- **线程池创建线程**：本质是通过 new Thread() 的方式实现
- **有返回值的Callable创建线程**：
- **定时器Timer**：本质是继承自 Thread 类实现
**Thread、Runnable和Callable的区别**
- Runnable相对于Thread的优势是：
- Thread使用JNI调用(native修饰的start0方法)系统函数来完成start， ，
- 一般情况，
- Callable能返回任务线程执行结果，
- Callable的call方法允许抛出异常，
**Thread.sleep(0)的作用是什么？**
由于Java采用抢占式的线程调度算法， ， ， ，
**wait()和sleep()的区别？**
- wait()来自Object ，
- 调用wait()时线程会释放锁， （ ）
- wait()只能在同步控制方法或者同步控制块中使用，
- wait()可以通过notify()或notifyAll()被结束 ，
## 线程创建方式
- 继承Thread类
- 实现Runnable接口
- ExecutorService、Callable、Future有返回值线程
- 基于线程池的方式
## 线程生命周期
Linux中线程状态一共有5种：
- **初始状态（ ） **NEW** 状态
- **可运行状态（ ） **RUNNBALE** 状态
- **运行状态（ ） **RUNNBALE** 状态
- **等待状态（ ） **BLOCKED** 、**WAITING**、**TIMED_WAITING** 三种状态
- **终止状态 （ ） **TERMINATED** 状态
Java中线程状态一共有6种（ ） ：
- **New（ ） ： ，
- **Runnable（ ） ： （ ） （ ） ， ） ， ， ， （ ） （ ）
- **Blocked（ ）
- **Waiting（ ）
- **Timed Waiting（ ） ： ，
- **Terminated（ ） ： ， ， ，
如果想要确定线程当前的状态，可以通过 getState() 方法，并且线程在任何时刻只可能处于 1 种状态。线程状态切换：
### 新建状态(NEW)
New 表示线程被创建但尚未启动的状态：当我们用 new Thread() 新建一个线程时，如果线程没有开始运行 start() 方法，所以也没有开始执行 run() 方法里面的代码，那么此时它的状态就是 New。而一旦线程调用了 start()，它的状态就会从 New 变成 Runnable，
### 可运行状态(RUNNABLE)
Java 中的 Runable 状态对应操作系统线程状态中的两种状态，分别是 Running 和 Ready， ，
所以，如果一个正在运行的线程是 Runnable 状态，当它运行到任务的一半时，执行该线程的 CPU 被调度去做其他事情，导致该线程暂时不运行，它的状态依然不变，还是 Runnable，
### 被阻塞状态(BLOCKED)
首先来看最简单的 Blocked， ，
### 等待状态(WAITING)
线程进入 Waiting 状态有三种可能性：
- 没有设置 Timeout 参数的 Object.wait() 方法
- 没有设置 Timeout 参数的 Thread.join() 方法
- LockSupport.park() 方法
Blocked 仅仅针对 synchronized monitor 锁，可是在 Java 中还有很多其他的锁，比如 ReentrantLock， ，
Blocked 与 Waiting 的区别是 Blocked 在等待其他线程释放 monitor 锁，而 Waiting 则是在等待某个条件，比如 join 的线程执行完毕，或者是 notify()/notifyAll() 。
### 计时等待状态(TIMED_WAITING)
在 Waiting 上面是 Timed Waiting 状态， ， ，
- 设置了时间参数的 Thread.sleep(long millis) 方法
- 设置了时间参数的 Object.wait(long timeout) 方法
- 设置了时间参数的 Thread.join(long millis) 方法
- 设置了时间参数的 LockSupport.parkNanos(long nanos) 方法和 LockSupport.parkUntil(long deadline) 方法
### 已终止状态(TERMINATED)
线程会以下面三种方式结束，结束后就是终止状态：
- **正常结束**：
- **异常结束**：线程抛出一个未捕获的 Exception 或 Error
- **调用** **stop** ：直接调用该线程的 stop()方法来结束该线程—该方法通常容易导致死锁，不推荐使用
## JDK线程池
### newCachedThreadPool
创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。
### newFixedThreadPool
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
### newScheduledThreadPool
创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
### newSingleThreadExecutor
Executors.newSingleThreadExecutor()返回一个线程池（这个线程池只有一个线程），这个线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去。
## 线程方法
### 线程等待(wait)
调用该方法的线程进入 WAITING 状态，只有等待另外线程的通知或被中断才会返回，需要注意的是调用 wait()方法后， ，
### 线程睡眠(sleep)
sleep 导致当前线程休眠，与 wait 方法不同的是 sleep 不会释放当前占有的锁,sleep(long)会导致线程进入 TIMED-WATING 状态，而 wait()方法会导致当前线程进入 WATING 状态。
### 线程让步(yield)
yield 会使当前线程让出 CPU 执行时间片，与其他线程一起重新竞争 CPU 时间片。一般情况下，优先级高的线程有更大的可能性成功竞争得到 CPU 时间片，但这又不是绝对的，有的操作系统对线程优先级并不敏感。
### 线程中(interrupt)
中断一个线程，其本意是给这个线程一个通知信号，会影响这个线程内部的一个中断标识位。这个线程本身并不会因此而改变状态(如阻塞，终止等)。
### 等待其他线程终止(join)
join() 方法，等待其他线程终止，在当前线程中调用一个线程的 join() 方法，则当前线程转为阻塞状态，回到另一个线程结束，当前线程再由阻塞状态变为就绪状态，等待 cpu 的宠幸。
### 线程唤醒(notify)
Object 类中的 notify() 方法，唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意的，并在对实现做出决定时发生，线程通过调用其中一个 wait() 方法，在对象的监视器上等待，直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程，被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。类似的方法还有 notifyAll() ，唤醒再次监视器上等待的所有线程。
## 线程安全
线程安全是指当多个线程访问某个类时，该类始终都表现正确行为，则称该类是线程安全的。
**出现线程安全问题的原因？**
在多个线程并发环境下，多个线程共同访问同一共享内存资源时，其中一个线程对资源进行写操作的中途(写⼊入已经开始，但还没结束)，其他线程对这个写了一半的资源进⾏了读操作，或者对这个写了一半的资源进⾏了写操作，导致此资源出现数据错误。
**如何避免线程安全问题？**
- 保证共享资源在同一时间只能由一个线程进行操作(原子性，有序性)
- 将线程操作的结果及时刷新，保证其他线程可以立即获取到修改后的最新数据（可见性）
## 线程同步
多个线程操作一个资源的情况下，导致资源数据前后不一致。这样就需要协调线程的调度，即线程同步。线程同步的方式：
- **同步方法（ ）
- **同步代码块（ ）
- **使用特殊域变量（ ）
- **使用重入锁（ ）
- **使用局部变量（ ）
- **使用阻塞队列（ ）
- **使用原子变量（ ）
## 多线程通信
多线程通讯的方式主要包括以下几种：
- **使用volatile关键词：
- **使用Synchronized+Object类的wait()/notify()/notifyAll()方法**
- **使用JUC工具类CountDownLatch：
- **使用Lock（ ）
- **基于LockSupport实现线程间的阻塞和唤醒**
## 线程协作
### sleep/yield/join
**sleep()**
- 让当前线程暂停指定的时间（毫秒）
- wait方法依赖于同步，
- sleep方法只是暂时让出CPU的执行权， ，
**yield()**
- 暂停当前线程， ，
- 不能指定暂停的时间，并且也不能保证当前线程马上停止
- 会让当前线程从运行状态转变为就绪状态
- yield只能使同优先级或更高优先级的线程有执行的机会
**join()**
- 等待调用 join 方法的线程执行结束，才执行后面的代码
- 其调用一定要在 start 方法之后（看源码可知）
- 作用是父线程等待子线程执行完成后再执行（即将异步执行的线程合并为同步的线程）
### wait/notify/notifyAll
一般需要配合**synchronized**一起使用。**Object**的主要方法如下：
- **wait()**：阻塞当前线程，直到 notify 或者 notifyAll 来唤醒
- **notify()**：只能唤醒一个处于 wait 的线程
- **notifyAll()**：唤醒全部处于 wait 的线程
### await/signal/signalAll
使用显式的 **Lock** 和 **Condition** 对象：
- **await()**： ， （ ）
- **signal()**： ，
- **signalAll()**：
## 线程死锁
**造成死锁的原因？**
多个线程竞争共享资源，由于资源被占用、资源不足或进程推进顺序不当等原因造成线程处于永久阻塞状态，从而引发死锁。死锁形成的原因：
- 系统资源不足
- 进程（线程）推进的顺序不恰当
- 资源分配不当
**死锁的解决办法？**
- 让程序每次至多只能获得一个锁（多线程环境中并不现实）
- 设计时考虑清楚锁的顺序，尽量减少嵌套加锁和交互数量
- 设置锁等待时间上限
## 守护线程
守护线程（ ） ： ， ； ， ：
- thread.setDaemon(true)必须在thread.start()之前设置，
- 在Daemon线程中产生的新线程也是Daemon的
- 不要认为所有的应用都可以分配给Daemon来进行服务，
## 常见问题
**sleep与wait区别**
- 来源不同：**wait** 来自**Object**， **Thread**
- 是否释放锁：**wait** 释放锁，**sleep** 不释放
- 使用范围：**wait** 必须在同步代码块中，**sleep** 可以任意使用
- 捕捉异常：**wait** 不需要捕获异常，**sleep** 需捕获异常
**start与run区别**
- start()方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码
- 通过调用 Thread 类的 start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行
- 方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了运行状态，开始运行 run 函数当中的代码。 Run 方法运行结束， 此线程终止。然后 CPU 再调度其它线程
**yield跟sleep区别**
- **yield** 跟 **sleep** 都能暂停当前线程，都**不会释放锁资源**， **yield** 则依赖 **CPU** 的时间片划分
- **sleep**方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会。**yield**方法只会给相同优先级或更高优先级的线程以运行的机会
- 调用 **sleep** 方法使线程进入**等待状态**，等待休眠时间达到，而调用我们的 **yield** 方法，线程会进入**就绪状态**，也就是**sleep**需要等待设置的时间后才会进行**就绪状态**，而**yield**会立即进入**就绪状态**
- **sleep**方法声明会抛出 **InterruptedException** ，而 **yield** 方法没有声明任何异常
- **yield** 不能被中断，而 **sleep** 则可以接受中断
- **sleep**方法比**yield**方法具有更好的移植性(跟操作系统CPU调度相关)
## ThreadLocal
把ThreadLocal看成一个全局Map< Thread , Object > ， ，
- ThreadLocal表示线程的"局部变量"，
- ThreadLocal适合在一个线程的处理流程中保持上下文（ ）
- 使用ThreadLocal要用try ... finally结构，
ThreadLocal常用的方法
- set： ，
- get： ，
- initialValue（ ） ： ， ， ，
- remove：
### 底层结构
### set流程
然后会判断一下： ， ；
```java
private void set(ThreadLocal< ?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 根据ThreadLocal对象的hash值，
int i = key.threadLocalHashCode & (len - 1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal< ?> k = e.get();
// 如果位置i不为空， ，
if (k == key) {
e.value = value;
return;
}
// 如果当前位置是空的，
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
// 如果位置i的不为空， ， ，
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) & & sz >= threshold)
rehash();
}
```
### get流程
在get的时候， ， ， ， ， ， ，
```java
private Entry getEntryAfterMiss(ThreadLocal< ?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// get的时候一样是根据ThreadLocal获取到table的i值， & & e.get() == key)。
while (e != null) {
ThreadLocal< ?> k = e.get();
// 相等就直接返回，不相等就继续查找，找到相等位置。
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
```
**如果想共享线程的ThreadLocal数据怎么办？
使用`InheritableThreadLocal`可以实现多个线程访问ThreadLocal的值，
### 内存泄露
ThreadLocal在保存的时候会把自己当做Key存在ThreadLocalMap中， ，
**弱引用**：只具有弱引用的对象拥有更短暂的生命周期，在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
这就导致了一个问题， ， ， ， ，
**解决**：
**那为什么ThreadLocalMap的key要设计成弱引用？
### InheritableThreadLocal
`InheritableThreadLocal` 是 JDK 本身自带的一种线程传递解决方案。顾名思义，由当前线程创建的线程，将会继承当前线程里 ThreadLocal 保存的值。
`JDK` 的`InheritableThreadLocal`类可以完成父线程到子线程的值传递。但对于使用线程池等会池化复用线程的执行组件的情况，线程由线程池创建好，并且线程是池化起来反复使用的；这时父子线程关系的`ThreadLocal`值传递已经没有意义，应用需要的实际上是把 ** 任务提交给线程池时**的`ThreadLocal`值传递到 ** 任务执行时**。
### TransmittableThreadLocal
**TransmittableThreadLocal** 是Alibaba开源的、用于解决 ** “在使用线程池等会缓存线程的组件情况下传递ThreadLocal”** 问题的 InheritableThreadLocal 扩展。若希望 TransmittableThreadLocal 在线程池与主线程间传递，需配合 TtlRunnable 和 TtlCallable使用。
**使用场景**
- 分布式跟踪系统
- 应用容器或上层框架跨应用代码给下层SDK传递信息
- 日志收集记录系统上下文
## ThreadPoolExecutor
ThreadPoolExecutor是如何运行， ？ ：
线程池在内部实际上构建了一个生产者消费者模型， ， ， ， ： ， ， ： （ ） ； （ ） ； （ ） ， ， ， ， ，
**线程池（ ）
线程池（ ） ，
线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。当然，使用线程池可以带来一系列好处：
- **降低资源消耗**：通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗
- **提高响应速度**：任务到达时，无需等待线程创建即可立即执行
- **提高线程的可管理性**：线程是稀缺资源，如果无限制创建，不仅会消耗系统资源，还会因为线程的不合理分布导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控
- **提供更多更强大的功能**： ， ，
**线程池要解决的两个问题**
- **解决频繁创建和销毁线程所产生的开销**。减少在创建和销毁线程上所花的时间以及系统资源的开销
- **解决无限制创建线程引起系统崩溃**。不使用线程池，可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”
**多线程优缺点**
- **多线程的优点**
- 资源利用率更好
- 程序设计在某些情况下更简单
- 程序响应更快
- **多线程的缺点**
- 设计更复杂
- 上下文切换的开销
- 增加资源消耗
**线程池类型**
JDK默认提供四种线程池：
- **newCachedThreadPool**：可变尺寸的线程池
- **newFixedThreadPool**：可重用的固定线程数的线程池
- **newScheduledThreadPool**：定时以及周期性执行任务的线程池
- **newSingleThreadExecutor**：单任务的线程池
### 重要参数
- **corePoolSize**（ ， ）
- 核心线程会一直存活，即使没有任务需要执行
- 当线程数＜核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理
- 设置allowCoreThreadTimeout=true（ ） ，
- **maximumPoolSize**（ ， ）
- 当线程数≥corePoolSize， ，
- 当线程数=maxPoolSize， ，
- **keepAliveTime**（ ， ， ）
- 当线程空闲时间达到keepAliveTime时， ，
- 如果allowCoreThreadTimeout=true，
- **unit**（ ） ：
- **workQueue**（ ， ， ）
- 当核心线程数达到最大时，新任务会放在队列中排队等待执行
- **threadFactory**（
- 通常用于线程命名
- 设置线程守护（ ）
- **allowCoreThreadTimeout**： ，
- **handler**（ ， ）
以下两种情况会拒绝处理任务：
- 当线程数已经达到maxPoolSize， ，
- 当线程池被调用shutdown()后， ， ，
### 线程池状态转换
下图为线程池的状态转换过程：
线程池最重要的5种状态：
- **RUNNING**：能接受新提交的任务，并且也能处理阻塞队列中的任务
- **SHUTDOWN**：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务。在线程池处于 RUNNING 状态时，调用 shutdown()方法会使线程池进入到该状态。（
- **STOP**：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于 RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态
- **TIDYING**： ， ，
- **TERMINATED**： ，
### execute销毁流程
**execute到线程销毁的整个流程图**
### 线程池的监控
通过线程池提供的参数进行监控。线程池里有一些属性在监控线程池的时候可以使用
- **getTaskCount**：线程池已经执行的和未执行的任务总数
- **getCompletedTaskCount**： ，
- **getLargestPoolSize**： ，
- **getPoolSize**：线程池当前的线程数量
- **getActiveCount**：当前线程池中正在执行任务的线程数量
### 生命周期
hreadPoolExecutor的运行状态有5种， ：
其生命周期转换如下入所示：
### 任务调度
线程池分配线程时，其执行过程如下：
- 首先检测线程池运行状态， ， ，
- **当线程数＜ （ ）
- **当线程数 ≥ 核心线程数（ ）
- **任务队列（ ）
- 将任务放入任务队列
- **任务队列（ ）
- **若线程数＜ （ ）
- **若线程数 = 最大线程数（ ）
### 任务缓冲
任务缓冲模块是线程池能够管理任务的核心部分。线程池的本质是对任务和线程的管理，而做到这一点最关键的思想就是将任务和线程两者解耦，不让两者直接关联，才可以做后续的分配工作。线程池中是以生产者消费者模式，通过一个阻塞队列来实现的。阻塞队列缓存任务，工作线程从阻塞队列中获取任务。使用不同的队列可以实现不一样的任务存取策略。以下是阻塞队列的成员：
### 任务申请
由上文的任务分配部分可知，任务的执行有两种可能：一种是任务直接由新创建的线程执行。另一种是线程从任务队列中获取任务然后执行，执行完任务的空闲线程会再次去从队列中申请任务再去执行。第一种情况仅出现在线程初始创建的时候，第二种是线程获取任务绝大多数的情况。
线程需要从任务缓存模块中不断地取任务执行， ， ， ：
getTask这部分进行了多次判断， ， ， ， ，
### 任务拒绝
任务拒绝模块是线程池的保护部分， ， ， ， ， ， ， ：
### 并发类型
**CPU密集型（ ）
CPU密集型（ ） ， ， ， ， ， ， ， ， ， ，
`线程数 = CPU核数 + 1`
JVM可运行的CPU核数可以通过`Runtime.getRuntime().availableProcessors()`查看。也可设置成CPU核数× ， （ ）
`线程数 = CPU内核线程数×
**IO密集型（ ）
对于IO密集型的应用， ， ， ， ， ， ， ， ， （ ， ） ， ， ， ：
`线程数=CPU数/(1-阻塞系数)`
`阻塞系数=线程等待时间/(线程等待时间+CPU处理时间) `
或 `线程数=CPU核数×
这个阻塞系数一般为 **0.8~0.9** 之间， ， ， ： ， ，
### 参数计算
**目标假设**
- **tasks** ：每秒的任务数假设为**500~1000**
- **taskCost**：每个任务花费时间假设为**0.1s**，则
- **corePoolSize**=TPS÷平均耗时
- **1÷taskCost**：表示单个线程每秒的处理能力（处理数量）
- **responseTime**：系统允许容忍的最大响应时间，假设为**1s**
- **queueCapacity**=corePoolSize÷平均耗时×
**参数计算**
- **每秒需要多少个线程处理（ ）
① corePoolSize = tasks ÷ (1 ÷ taskCost) = (500~1000) ÷ (1 ÷ 0.1) = 50~100个线程
② 根据2/8原则， ，
- **线程池缓冲队列大小（ ） ×
① queueCapacity = 80÷0.1× ， ，
② 禁止设置为Integer.MAX_VALUE， ， ，
- **最大线程数（ ）
① 计算可得 maximumPoolSize = (1000 - 80) ÷ 10 = 92
- rejectedExecutionHandler： ， ，
- keepAliveTime和allowCoreThreadTimeout采用默认通常能满足
- prestartAllCoreThreads： ，
**注意：** 以上都是理想值， ， ，
# Lock
## synchronized
`synchronized` 是依赖监视器 `Monitor` 实现方法同步或代码块同步的，代码块同步使用的是 `monitorenter` 和 `monitorexit` 指令来实现的：
- monitorenter指令：
- monitorexit指令：
任何对象都有一个 Monitor 与之关联，当且一个 Monitor 被持有后， ** 互斥锁**， ， ** 原子性** 和 ** 可见性** 。
共享资源代码段又称为**临界区**（ （
**synchronize缺点**
- 性能较低
- 无法中断一个正在等候获得锁的线程
- 无法通过投票得到锁，如果不想等下去，也就没办法得到锁
**synchronized和lock的区别**
| compare | synchronized | lock |
| :------ | :----------------------- | :---------------------------------------- |
| 哪层面 | 虚拟机层面 | 代码层面 |
| 锁类型 | 可重入、不可中断、非公平 | 可重入、可中断、可公平 |
| 锁获取 | A线程获取锁，
| 锁释放 | 由JVM 释放锁 | 在finally中手动释放。如不释放，
| 锁状态 | 无法判断 | 可以判断 |
### Monitor
在多线程的 JAVA程序中， ， ， ， ， ， ：
- **进入区(Entrt Set)**： ， ； ，
- **拥有者(The Owner)**：表示某一线程成功竞争到对象锁
- **等待区(Wait Set)** ： ， ，
从图中可以看出，一个 Monitor在某个时刻， ， ， ， ， ，
### 使用方式
`Synchronized` 的使用方式有三种：
- **修饰普通函数**。监视器锁（`monitor`）便是对象实例（`this`）
- **修饰静态函数**。视器锁（`monitor`）便是对象的`Class`实例（每个对象只有一个`Class`实例）
- **修饰代码块**。监视器锁（`monitor`）是指定对象实例
**修饰普通函数**
**修饰静态函数**
**修饰代码块**
### synchronized原理
### synchronized优化
`Jdk 1.5` 以后对`Synchronized`关键字做了各种的优化，经过优化后`Synchronized`已经变得原来越快了，这也是为什么官方建议使用`Synchronized`的原因，具体的优化点如下：
- **轻量级锁和偏向锁**：引入轻量级锁和偏向锁来减少重量级锁的使用
- **适应性自旋（ ）
- **锁粗化（ ）
- **锁消除（ ）
### 锁膨胀机制
`Java` 中每个对象都拥有对象头，对象头由`Mark World` 、指向类的指针、以及数组长度三部分组成，本文，我们只需要关心`Mark World` 即可，`Mark World` 记录了对象的`HashCode`、分代年龄和锁标志位信息。**Mark World简化结构：
| 锁状态 | 存储内容 | 锁标记 |
| :------- | :------------------------------------------------------ | :----- |
| 无锁 | 对象的hashCode、对象分代年龄、是否是偏向锁（ ）
| 偏向锁 | 偏向线程ID、偏向时间戳、对象分代年龄、是否是偏向锁（ ）
| 轻量级锁 | 指向栈中锁记录的指针 | 00 |
| 重量级锁 | 指向互斥量（重量级锁）的指针 | 10 |
锁的升级变化，体现在锁对象的对象头`Mark World`部分，也就是说`Mark World`的内容会随着锁升级而改变。`Java1.5`以后为了减少获取锁和释放锁带来的性能消耗，引入了**偏向锁**和**轻量级锁**，
#### 偏向锁
HotSpot 作者经过研究实践发现，在大多数情况下，锁不存在多线程竞争，总是由同一线程多次获得的，为了让线程获得锁的代价更低，于是就引进了偏向锁。
偏向锁（ ） ， ， ， ， ， ，
**偏向锁执行流程**
当一个线程访问同步代码块并获取锁时，会在对象头的 Mark Word 里存储锁偏向的线程 ID，
**偏向锁的优点**
偏向锁是为了在无多线程竞争的情况下，尽量减少不必要的锁切换而设计的，因为锁的获取及释放要依赖多次 CAS 原子指令，而偏向锁只需要在置换线程 ID 的时候执行一次 CAS 原子指令即可。
**Mark Word**
在 HotSpot 虚拟机中，对象在内存中存储的布局可以分为以下 3 个区域：
- **对象头（ ）
- **实例数据（ ）
- **对齐填充（ ）
对象头中又包含了：
- **Mark Word（ ） ：
- **Klass Pointer（
对象在内存中的布局如下：
在 JDK 1.6 中默认是开启偏向锁的，可以通过“-XX:-UseBiasedLocking=false”命令来禁用偏向锁。
#### 轻量级锁
**轻量级锁考虑的是竞争锁对象的线程不多，持有锁时间也不长的场景**。因为阻塞线程需要CPU从用户态转到内核态， ， ， ， ， ， ， ， ， ，
**注意事项**
需要强调一点：**轻量级锁并不是用来代替重量级锁的**，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用产生的性能消耗。轻量级锁所适应的场景是线程交替执行同步块的情况，如果同一时间多个线程同时访问时，就会导致轻量级锁膨胀为重量级锁。
#### 重量级锁
轻量级锁膨胀之后， ， （ ） ， ， ，
升级为重量级锁时， ， ， ，
## ReentrantLock
ReentrantLock的底层是借助AbstractQueuedSynchronizer实现， ， ， ，
- ReentrantLock是一个可重入的互斥锁，
- ReentrantLock锁在同一个时间点只能被一个线程锁持有； ，
- ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下， ； ，
**ReentrantLock和synchronized比较**
- synchronized是独占锁， ， ， ， ， ，
- synchronized可重入， ， ； ， ， ，
- synchronized不可响应中断， ；
## ReentrantReadWriteLock
**数据结构**
- ReentrantReadWriteLock实现了ReadWriteLock接口。ReadWriteLock是一个读写锁的接口，
- ReentrantReadWriteLock中包含： ， ， ， ，
- 和"ReentrantLock"一样， ； ，
## 锁的状态
- 锁的4种状态：
- 锁状态只能升级不能降级
- 锁的状态是通过对象监视器在对象头中的字段来表明的
**锁的升级流程**
- **偏向锁：** 指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价
- **轻量级锁：** 指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其它线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能
- **重量级锁：** 指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其它申请的线程进入阻塞，性能降低
**Java对象头**
Hotspot虚拟机的对象头主要包括两部分数据（ ） ：
- **Mark Word（ ） ： ， ， ，
- **Klass Point（ ）
**Monitor**
- Monitor可以理解为一个同步工具或一种同步机制
- synchronized通过Monitor来实现线程同步
- Monitor是依赖于底层的操作系统的Mutex Lock（ ）
- 每一个Java对象就有一把看不见的锁，
- Monitor是线程私有的数据结构， ，
**锁状态升级流程**
- **偏向锁**： ，
- **轻量级锁**： ，
- **重量级锁**：将除了拥有锁的线程以外的线程都阻塞
**优缺点对比**
| 锁 | 优点 | 缺点 | 适用场景 |
| :------- | :----------------------------------------------------------- | :--------------------------------------------- | :--------------------------------- |
| 偏向锁 | 加锁和解锁不需要额外的消耗，和执行非同步方法相比仅存在纳秒级的差距 | 如果线程间存在锁竞争，会带来额外的锁撤销的消耗 | 适用于只有一个线程访问同步块的场景 |
| 轻量级锁 | 竞争的线程不会阻塞，提高了程序的响应速度 | 如果始终得不到锁竞争的线程，
| 重量级锁 | 线程竞争不使用自旋，
### 无锁
- 无锁是指没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功
- 修改操作在循环内进行，线程会不断的尝试修改共享资源
- CAS即是无锁的实现
- 无锁无法全面代替有锁，但无锁在某些场合下的性能是非常高的
### 偏向锁
指同步代码一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价。适用于只有一个线程访问同步块场景。
- **优点**：加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距
- **缺点**：如果线程间存在锁竞争，会带来额外的锁撤销的消耗
### 轻量级锁
指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其它线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。适用于追求响应时间，同步块执行速度非常快。
- **优点**：竞争的线程不会阻塞，提高了程序的响应速度
- **缺点**：
### 重量级锁
指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其它申请的线程进入阻塞，性能降低。适用于追求吞吐量，同步块执行速度较长。
- **优点**： ，
- **缺点**：线程阻塞，响应时间缓慢
## 自旋锁(SpinLock)
**指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环**。普通自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。其特点如下：
- 自旋锁适用于锁保护的临界区很小的情况，临界区很小的话，锁占用的时间就很短
- 阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，
- 如果同步代码块中的内容过于简单，状态转换消耗的时间有可能比用户代码执行的时间还要长
.png)
简单代码实现：
```java
public class SpinLock {
private AtomicReference< Thread > owner = new AtomicReference< Thread > ();
public void lock() {
Thread currentThread = Thread.currentThread();
// 如果锁未被占用，则设置当前线程为锁的拥有者
while (owner.compareAndSet(null, currentThread)) {
}
}
public void unlock() {
Thread currentThread = Thread.currentThread();
// 只有锁的拥有者才能释放锁
owner.compareAndSet(currentThread, null);
}
}
```
**缺点**
- CAS操作需要硬件的配合
- 保证各个CPU的缓存（ ） ， ，
- 没法保证公平性，不保证等待进程/线程按照FIFO顺序获得锁
### Ticket Lock
TicketLock即为排队自旋锁。思路： ， ， ： ， ， ， ：
```java
public class TicketLock {
private AtomicInteger serviceNum = new AtomicInteger(); // 服务号
private AtomicInteger ticketNum = new AtomicInteger(); // 排队号
public int lock() {
// 首先原子性地获得一个排队号
int myTicketNum = ticketNum.getAndIncrement();
// 只要当前服务号不是自己的就不断轮询
while (serviceNum.get() != myTicketNum) {
}
return myTicketNum;
}
public void unlock(int myTicket) {
// 只有当前线程拥有者才能释放锁
int next = myTicket + 1;
serviceNum.compareAndSet(myTicket, next);
}
}
```
**缺点**
Ticket Lock 虽然解决了公平性的问题，但是多处理器系统上，每个进程/线程占用的处理器都在读写同一个变量，每次读写操作都必须在多个处理器缓存之间进行缓存同步，这会导致繁重的系统总线和内存的流量，大大降低系统整体的性能。
### MCS Lock
MCS SpinLock 是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，直接前驱负责通知其结束自旋，从而极大地减少了不必要的处理器缓存同步的次数，降低了总线和内存的开销。
```java
public class MCSLock {
public static class MCSNode {
MCSNode next;
boolean isLocked = true; // 默认是在等待锁
}
volatile MCSNode queue ;// 指向最后一个申请锁的MCSNode
private static final AtomicReferenceFieldUpdater< MCSLock , MCSNode > UPDATER =
AtomicReferenceFieldUpdater.newUpdater(MCSLock.class, MCSNode. class, "queue" );
public void lock(MCSNode currentThread) {
MCSNode predecessor = UPDATER.getAndSet(this, currentThread);// step 1
if (predecessor != null) {
predecessor.next = currentThread;// step 2
while (currentThread.isLocked ) {// step 3
}
}
}
public void unlock(MCSNode currentThread) {
if ( UPDATER.get( this ) == currentThread) {// 锁拥有者进行释放锁才有意义
if (currentThread.next == null) {// 检查是否有人排在自己后面
if (UPDATER.compareAndSet(this, currentThread, null)) {// step 4
// compareAndSet返回true表示确实没有人排在自己后面
return;
} else {
// 突然有人排在自己后面了，可能还不知道是谁，下面是等待后续者
// 这里之所以要忙等是因为： ，
while (currentThread.next == null) { // step 5
}
}
}
currentThread.next.isLocked = false;
currentThread.next = null;// for GC
}
}
}
```
### CLH Lock
CLH（ ） ， ， ，
```java
public class CLHLock {
public static class CLHNode {
private boolean isLocked = true; // 默认是在等待锁
}
@SuppressWarnings ("unused" )
private volatile CLHNode tail ;
private static final AtomicReferenceFieldUpdater< CLHLock , CLHNode > UPDATER = AtomicReferenceFieldUpdater
. newUpdater(CLHLock.class, CLHNode .class , "tail" );
public void lock(CLHNode currentThread) {
CLHNode preNode = UPDATER.getAndSet( this, currentThread);
if(preNode != null) {//已有线程占用了锁，进入自旋
while(preNode.isLocked ) {
}
}
}
public void unlock(CLHNode currentThread) {
// 如果队列里只有当前线程， （ ）
if (!UPDATER .compareAndSet(this, currentThread, null)) {
// 还有后续线程
currentThread. isLocked = false ;// 改变状态，让后续线程结束自旋
}
}
}
```
**CLH优势**
- 公平、FIFO、先来后到的顺序进入锁
- 且没有竞争同一个变量，因为每个线程只要等待自己的前继释放即可
**CLH锁与MCS锁的比较**
- 从代码实现来看，
- 从自旋的条件来看， ，
- 从链表队列来看， ， ；
- CLH锁释放时只需要改变自己的属性，
## 常见锁
### 乐观锁/悲观锁
**悲观锁**
当线程去操作数据的时候， ， ， ，
**乐观锁**
每次去拿数据的时候都认为别人不会修改， ， ， ， ， ， ， ， ， ，
**小结**：悲观锁适合写操作多的场景，乐观锁适合读操作多的场景，乐观锁的吞吐量会比悲观锁大。
### 公平锁/非公平锁
**公平锁**
指多个线程按照申请锁的顺序来获取锁，简单来说 如果一个线程组里，能保证每个线程都能拿到锁 比如ReentrantLock(底层是同步队列FIFO: First Input First Output来实现)
**非公平锁**
获取锁的方式是随机获取的， ， ， ，
**小结**： ， ， ！ ，
### 可重入锁/不可重入锁
**可重入锁**
也叫递归锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁。一个线程获取锁之后再尝试获取锁时会自动获取锁，可重入锁的优点是避免死锁。
**不可重入锁**
若当前线程执行某个方法已经获取了该锁，那么在方法中尝试再次获取锁时，就会获取不到被阻塞。
**小结**：可重入锁能一定程度的避免死锁 synchronized、ReentrantLock都是可重入锁。
### 独占锁/共享锁
**独享锁**
指锁一次只能被一个线程持有。也叫X锁/排它锁/写锁/独享锁：该锁每一次只能被一个线程所持有，加锁后任何线程试图再次加锁的线程会被阻塞，直到当前线程解锁。例子：如果 线程A 对 data1 加上排他锁后，则其他线程不能再对 data1 加任何类型的锁，获得独享锁的线程即能读数据又能修改数据！
**共享锁**
指锁一次可以被多个线程持有。也叫S锁/读锁，能查看数据，但无法修改和删除数据的一种锁，加锁后其它用户可以并发读取、查询数据，但不能修改，增加，删除数据，该锁可被多个线程所持有，用于资源数据共享！
**小结**： ， ，
### 互斥锁/读写锁
与独享锁/共享锁的概念差不多，是独享锁/共享锁的具体实现。
ReentrantLock和synchronized都是互斥锁，
### 自旋锁
**自旋锁**
- 一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环，任何时刻最多只能有一个执行单元获得锁。
- 不会发生线程状态的切换， ， ，
**常见的自旋锁**： ， ，
## 锁优化
### 偏向锁/轻量级锁
**偏向锁**
大多数情况下锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了 `让线程获得锁的代价更低` 而引入了偏向锁， ，
**轻量级锁**
对于轻量级锁，其性能提升依据:“`对于绝大部分锁，在整个生命周期内都是不会存在竞争的`”。轻量级锁的目标：`减少无实际竞争情况下，使用重量级锁产生的性能消耗`，包括系统调用引起的内核态与用户态切换、线程阻塞造成的线程切换等。
### 自旋锁
**背景**
线程的阻塞和唤醒需要CPU从用户态转为核心态， ， ， ，
**定义**
自旋锁就是 `让该线程等待（即执行一段无意义的循环为自旋）固定的一段时间` ，不会被立即挂起，看持有锁的线程是否会很快释放锁。
**弊端**
自旋可以避免线程切换带来的开销， （ ） ， ， （ ） （ ） ， ， ，
### 适应性自旋锁
所谓自适应就意味着 `自旋的次数不再是固定的` ，它是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。
- **自旋成功，次数增加**：因为虚拟机认为既然上次成功，那么此次自旋也很有可能会再次成功，那么它就会允许自旋等待持续的次数更多
- **自旋失败，次数减少**：如果对于某个锁，很少有自旋能够成功的，那么在以后要获得这个锁的时候自旋的次数会减少甚至省略掉自旋过程，以免浪费处理器资源
### 锁消除
为了保证数据的完整性， ， ， ， ， `逃逸分析` 的数据支持。
锁消除主要是解决我们使用JDK内置API时存在的 `隐形加锁操作` 。如StringBuffer、Vector、HashTable等， ，
```java
public void vectorTest(){
Vector< String > vector = new Vector< String > ();
for(int i = 0 ; i < 10 ; i + + ) {
vector.add(i + "");
}
System.out.println(vector);
}
```
在运行这段代码时， ，
### 锁粗化
在使用同步锁的时候，需要让同步块的作用范围尽可能小，仅在共享数据的实际作用域中才进行同步，这样做的目的是为了使需要同步的操作数量尽可能缩小，如果存在锁竞争，那么等待锁的线程也能尽快拿到锁。
在大多数情况下，上述观点是正确的。但如果 `一系列的连续加锁解锁操作，可能会导致不必要的性能损耗` ，所以引入锁粗化的概念。锁粗化概念比较好理解，就是 `将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁` 。
如上面实例： ， （ ） ， ，
### 分段锁
分段锁其实是一种锁的设计，并不是具体的一种锁，对于 `ConcurrentHashMap` 而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。
### 锁细化
- **减少锁的时间**：不需要同步执行的代码，能不放在同步快里面执行就不要放在同步快内，可以让锁尽快释放
- **减少锁的粒度**：将物理上的一个锁，拆成逻辑上的多个锁，增加并行度，从而降低锁竞争。其思想是用空间来换时间
# Throwable
## Error
Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。
## Exception
### CheckedException
检查异常（ ） ， ， ， ：
- 试图在文件尾部读取数据
- 试图打开一个错误格式的 URL
- 试图根据给定的字符串查找 class 对象，而这个字符串表示的类并不存在
### RuntimeException
运行时异常（ ） ： ； ， ，
## 异常处理方式
抛出异常有三种形式：
- throw
- throws
- 系统自动抛异常
**throw 和 throws 的区别**
- throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的是异常对象
- throws 用来声明异常， ， ； ， ， ，
- throws 表示出现异常的一种可能性， ；
- 两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理
# Others
## Annotation
## JAVA内部类
Java 类中不仅可以定义变量和方法，还可以定义类，这样定义在类内部的类就被称为内部类。根据定义的方式不同，内部类分为静态内部类、成员内部类、局部内部类和匿名内部类四种。
### 静态内部类
使用static修饰的内部类我们称之为静态内部类， ， ， ， ：
- 它的创建是不需要依赖于外围类的
- 它不能使用任何外围类的非static成员变量和方法
```java
public class OuterClass {
private String sex;
public static String name = "chenssy";
/**
*静态内部类
*/
static class InnerClass1{
/* 在静态内部类中可以存在静态成员 */
public static String _name1 = "chenssy_static";
public void display(){
/*
* 静态内部类只能访问外围类的静态成员变量和方法
* 不能访问外围类的非静态成员变量和方法
*/
System.out.println("OutClass name :" + name);
}
}
/**
* 非静态内部类
*/
class InnerClass2{
/* 非静态内部类中不能存在静态成员 */
public String _name2 = "chenssy_inner";
/* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */
public void display(){
System.out.println("OuterClass name：
}
}
/**
* @desc 外围类方法
* @author chenssy
* @data 2013-10-25
* @return void
*/
public void display(){
/* 外围类访问静态内部类：内部类. */
System.out.println(InnerClass1._name1);
/* 静态内部类 可以直接创建实例不需要依赖于外围类 */
new InnerClass1().display();
/* 非静态内部的创建需要依赖于外围类 */
OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
/* 方位非静态内部类的成员需要使用非静态内部类的实例 */
System.out.println(inner2._name2);
inner2.display();
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.display();
}
}
```
### 成员内部类
成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法， ， ：
- **成员内部类中不能存在任何static的变量和方法**
- **成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类**
- **推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时**
```java
public class OuterClass {
private String str;
public class InnerClass{
public void innerDisplay(){
//使用外围内的属性
str = "chenssy...";
System.out.println(str);
//使用外围内的方法
outerDisplay();
}
}
/* 推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 */
public InnerClass getInnerClass(){
return new InnerClass();
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.getInnerClass();
inner.innerDisplay();
}
}
```
### 局部内部类
有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。
- 定义在方法里：
```java
public class Parcel5 {
public Destionation destionation(String str){
class PDestionation implements Destionation{
private String label;
private PDestionation(String whereTo){
label = whereTo;
}
public String readLabel(){
return label;
}
}
return new PDestionation(str);
}
public static void main(String[] args) {
Parcel5 parcel5 = new Parcel5();
Destionation d = parcel5.destionation("chenssy");
}
}
```
- 定义在作用域内：
```java
public class Parcel6 {
private void internalTracking(boolean b){
if(b){
class TrackingSlip{
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip(){
return id;
}
}
TrackingSlip ts = new TrackingSlip("chenssy");
String string = ts.getSlip();
}
}
public void track(){
internalTracking(true);
}
public static void main(String[] args) {
Parcel6 parcel6 = new Parcel6();
parcel6.track();
}
}
```
### 匿名内部类
- 匿名内部类是没有访问修饰符的
- new 匿名内部类， ，
- 注意getInnerClass()方法的形参， ， ， ，
- 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法
```java
button2.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e) {
System.out.println("你按了按钮二");
}
});
```
## 泛型
### 获取类泛型类型
获取当前类上的泛型类型方式如下：
```java
public class DefaultTargetType< T > {
private Type type;
private Class< T > classType;
@SuppressWarnings ("unchecked")
public DefaultTargetType() {
Type superClass = getClass().getGenericSuperclass();
this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
if (this.type instanceof ParameterizedType) {
this.classType = (Class< T > ) ((ParameterizedType) this.type).getRawType();
} else {
this.classType = (Class< T > ) this.type;
}
}
}
```
获取到泛型中的类型方式：
```java
Class< List < User > > classType = new DefaultTargetType< List < User > >() {}.getClassType();
```
### 获取接口泛型类型
获取当前类的父类接口上的泛型类型方式如下：
```java
public class DefaultTargetType implements TargetType< T > {
private Type type;
private Class< T > classType;
@SuppressWarnings ("unchecked")
public DefaultTargetType() {
Type superClass = getClass().getGenericInterfaces()[0];
this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
if (this.type instanceof ParameterizedType) {
this.classType = (Class< T > ) ((ParameterizedType) this.type).getRawType();
} else {
this.classType = (Class< T > ) this.type;
}
}
}
```
获取到泛型中的类型方式：
```java
Class< List < User > > classType = new DefaultTargetType< List < User > >() {}.getClassType();
```
## JAVA复制
### 浅复制
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
### 深复制
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。
