学习随笔简介
跟随着黑马满老师的《Java八股文面试题视频教程，Java面试八股文宝典》学习，视频教程地址：Java八股文面试题视频教程，Java面试八股文宝典（含阿里、腾迅大厂java面试真题，java数据结构，java并发，jvm等最新java面试真题）_哔哩哔哩_bilibili
共分为四个部分，分别是 基础篇、并发篇、虚拟机、框架篇
本篇更新并发篇的内容（并发篇已完结）
目录
七、 HashTable VS ConcurrentHashMap
一、 线程状态
【面试题】线程有哪些状态？
1.六种状态（Java线程）
Java线程分为六种状态：
分别是
-
新建
-
当一个线程对象被创建，但还未调用 start 方法时处于新建状态
-
此时未与操作系统底层线程关联
-
-
可运行
-
调用了 start 方法，就会由新建进入可运行
-
此时与底层线程关联，由操作系统调度执行
-
-
终结
-
线程内代码已经执行完毕，由可运行进入终结
-
此时会取消与底层线程关联
-
-
阻塞
-
当获取锁失败后，由可运行进入 Monitor 的阻塞队列阻塞，此时不占用 cpu 时间
-
当持锁线程释放锁时，会按照一定规则唤醒阻塞队列中的阻塞线程，唤醒后的线程进入可运行状态
-
-
等待
-
当获取锁成功后，但由于条件不满足，调用了 wait() 方法，此时从可运行状态释放锁进入 Monitor 等待集合等待，同样不占用 cpu 时间
-
当其它持锁线程调用 notify() 或 notifyAll() 方法，会按照一定规则唤醒等待集合中的等待线程，恢复为可运行状态
-
-
有时限等待
-
当获取锁成功后，但由于条件不满足，调用了 wait(long) 方法，此时从可运行状态释放锁进入 Monitor 等待集合进行有时限等待，同样不占用 cpu 时间
-
当其它持锁线程调用 notify() 或 notifyAll() 方法，会按照一定规则唤醒等待集合中的有时限等待线程，恢复为可运行状态，并重新去竞争锁
-
如果等待超时，也会从有时限等待状态恢复为可运行状态，并重新去竞争锁
-
还有一种情况是调用 sleep(long) 方法也会从可运行状态进入有时限等待状态，但与 Monitor 无关，不需要主动唤醒，超时时间到自然恢复为可运行状态
-
2.五种状态（操作系统）
操作系统层面分为五种状态 ：
-
运行态：分到 cpu 时间，能真正执行线程内代码的
-
就绪态：有资格分到 cpu 时间，但还未轮到它的
-
阻塞态：没资格分到 cpu 时间的
-
涵盖了 java 状态中提到的阻塞、等待、有时限等待
-
多出了阻塞 I/O，指线程在调用阻塞 I/O 时，实际活由 I/O 设备完成，此时线程无事可做，只能干等
-
-
新建与终结态：与 java 中同名状态类似，不再啰嗦
二、 线程池
1.七大参数
-
corePoolSize 核心线程数目 - 池中会保留的最多线程数
-
maximumPoolSize 最大线程数目 = 核心线程+救急线程的最大数目
-
keepAliveTime 生存时间 - 救急线程的生存时间，生存时间内没有新任务，此线程资源会释放
-
unit 时间单位 - 救急线程的生存时间单位，如秒、毫秒等
-
workQueue - 当没有空闲核心线程时，新来任务会加入到此队列排队，队列满会创建救急线程执行任务
-
threadFactory 线程工厂 - 可以定制线程对象的创建，例如设置线程名字、是否是守护线程等
-
handler 拒绝策略 - 当所有线程都在繁忙，workQueue 也放满时，会触发拒绝策略
-
抛异常 java.util.concurrent.ThreadPoolExecutor.AbortPolicy
-
由调用者执行任务 java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
-
丢弃任务 java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
-
丢弃最早排队任务 java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy
-
三、 wait vs sleep
1.区别
共同点
-
wait() ，wait(long) 和 sleep(long) 的效果都是让当前线程暂时放弃 CPU 的使用权，进入阻塞状态
不同点
-
方法归属不同
-
sleep(long) 是 Thread 的静态方法
-
而 wait()，wait(long) 都是 Object 的成员方法，每个对象都有
-
-
醒来时机不同
-
执行 sleep(long) 和 wait(long) 的线程都会在等待相应毫秒后醒来
-
wait(long) 和 wait() 还可以被 notify 唤醒，wait() 如果不唤醒就一直等下去
-
它们都可以被打断唤醒
-
-
锁特性不同（重点）
-
wait 方法的调用必须先获取 wait 对象的锁，而 sleep 则无此限制
-
wait 方法执行后会释放对象锁，允许其它线程获得该对象锁（我放弃 cpu，但你们还可以用）
-
而 sleep 如果在 synchronized 代码块中执行，并不会释放对象锁（我放弃 cpu，你们也用不了）
-
四、 lock vs synchronized
1.区别（三个层面）
-
语法层面
-
synchronized 是关键字，源码在 jvm 中，用 c++ 语言实现
-
Lock 是接口，源码由 jdk 提供，用 java 语言实现
-
使用 synchronized 时，退出同步代码块锁会自动释放，而使用 Lock 时，需要手动调用 unlock 方法释放锁
-
-
功能层面
-
二者均属于悲观锁、都具备基本的互斥、同步、锁重入功能
-
Lock 提供了许多 synchronized 不具备的功能，例如获取等待状态、公平锁、可打断、可超时、多条件变量
-
Lock 有适合不同场景的实现，如 ReentrantLock， ReentrantReadWriteLock
-
-
性能层面
-
在没有竞争时，synchronized 做了很多优化，如偏向锁、轻量级锁，性能不赖
-
在竞争激烈时，Lock 的实现通常会提供更好的性能
-
2.公平锁
-
公平锁的公平体现
-
已经处在阻塞队列中的线程（不考虑超时）始终都是公平的，先进先出
-
公平锁是指未处于阻塞队列中的线程来争抢锁，如果队列不为空，则老实到队尾等待
-
非公平锁是指未处于阻塞队列中的线程来争抢锁，与队列头唤醒的线程去竞争，谁抢到算谁的
-
-
公平锁会降低吞吐量，一般不用
3.条件变量
-
ReentrantLock 中的条件变量功能类似于普通 synchronized 的 wait，notify，用在当线程获得锁后，发现条件不满足时，临时等待的链表结构
-
与 synchronized 的等待集合不同之处在于，ReentrantLock 中的条件变量可以有多个，可以实现更精细的等待、唤醒控制
五、 volatile
1.线程安全
线程安全需要考虑三个方面：可见性、有序性、原子性
- 可见性：一个线程对共享变量进行修改，另一个线程可以看到最新的结果
- 有序性：一个线程内代码按编写顺序执行
- 原子性：一个线程内多行代码以一个整体运行，期间不能有其他线程的代码插队
三个特性造成的原因：
- 可见性：由于编译器优化、或缓存优化、或 CPU 指令重排序优化导致的对共享变量所做的修改另外的线程看不到
- 有序性：由于编译器优化、或缓存优化、或 CPU 指令重排序优化导致指令的实际执行顺序与编写顺序不一致
- 原子性：多线程下，不同线程的指令发生了交错导致的共享变量的读写混乱
2.volatile的作用
volatile可见保证共享变量的可见性和有序性，但不能保证原子性
- 可见性：用volatile修饰的共享变量，能够防止编译器等优化发生，让一个线程对共享变量的修改对另一个线程可见
- 有序性：用volatile修饰共享变量会在读、写共享变量时加入不同的内存屏障，阻止其他读写操作越过屏障，从而达到阻止重排序的结果
对于有序性，此处有需要注意的点：
- volatile变量写加的屏障是阻止上方其它写操作越过屏障排到 volatile 变量写之下
-
volatile 变量读加的屏障是阻止下方其它读操作越过屏障排到 volatile 变量读之上
-
volatile 读写加入的屏障只能防止同一线程内的指令重排
六、 乐观锁和悲观锁
1.乐观锁
-
乐观锁的代表是 AtomicInteger，使用 CAS 来保证原子性
-
其核心思想是【无需加锁，每次只有一个线程能成功修改共享变量，其它失败的线程不需要停止，不断重试直至成功】
-
由于线程一直运行，不需要阻塞，因此不涉及线程上下文切换
-
它需要多核 cpu 支持，且线程数不应超过 cpu 核数
-
【补】CAS：Compare And Swap（比较并交换），底层是有三个操作数，分别是内存值、预期值、更新值。只有当内存值和预期值相等的时候，才会去修改为更新值。
- 优点：避免死锁的产生，没有锁竞争
- 缺点：
- 底层是通过do-while来完成锁自旋，开销较大
- 会导致ABA问题（所谓的ABA问题就是A线程修改B中的原本值修改为新值，另一个A线程又将新值修改为原本值，B无法得知这一变化）
- 只能保证单个变量
2.悲观锁
-
悲观锁的代表是 synchronized 和 Lock 锁
-
其核心思想是【线程只有占有了锁，才能去操作共享变量，每次只有一个线程占锁成功，获取锁失败的线程，都得停下来等待】
-
线程从运行到阻塞、再从阻塞到唤醒，涉及线程上下文切换，如果频繁发生，影响性能
-
实际上，线程在获取 synchronized 和 Lock 锁时，如果锁已被占用，都会做几次重试操作，减少阻塞的机会
-
七、 HashTable VS ConcurrentHashMap
1.两者区别与联系
-
Hashtable 与 ConcurrentHashMap 都是线程安全的 Map 集合
-
Hashtable 并发度低，整个 Hashtable 对应一把锁，同一时刻，只能有一个线程操作它
-
ConcurrentHashMap 并发度高，整个 ConcurrentHashMap 对应多把锁，只要线程访问的是不同锁，那么不会冲突
2.细说ConcurrentHashMap
在JDK1.7中：
-
数据结构：
Segment(大数组) + HashEntry(小数组) + 链表，每个 Segment 对应一把锁，如果多个线程访问不同的 Segment，则不会冲突 -
并发度：Segment 数组大小即并发度，决定了同一时刻最多能有多少个线程并发访问。Segment 数组不能扩容，意味着并发度在 ConcurrentHashMap 创建时就固定了
-
索引计算：
-
假设大数组长度是 2的m次方，key 在大数组内的索引是 key 的二次 hash 值的高 m 位
-
假设小数组长度是 2的n次方，key 在小数组内的索引是 key 的二次 hash 值的低 n 位
-
-
扩容：每个小数组的扩容相对独立，小数组在超过扩容因子时会触发扩容，每次扩容翻倍
-
Segment[0] 原型：首次创建其它小数组时，会以此原型为依据，数组长度，扩容因子都会以原型为准
在JDK1.8中：
-
数据结构：
Node 数组 + 链表 + 红黑树，数组的每个头节点作为锁，如果多个线程访问的头节点不同，则不会冲突。首次生成头节点时如果发生竞争，利用 CAS而非 syncronized，进一步提升性能 -
并发度：Node 数组有多大，并发度就有多大，与 1.7 不同，Node 数组可以扩容
-
扩容条件：Node 数组满 3/4 时就会扩容
-
扩容单位：以链表为单位从后向前迁移链表，迁移完成的将旧数组头节点替换为 ForwardingNode
-
扩容时并发 get：
-
根据是否为 ForwardingNode 来决定是在新数组查找还是在旧数组查找，不会阻塞
-
如果链表长度超过 1，则需要对节点进行复制（创建新节点），怕的是节点迁移后 next 指针改变
-
如果链表最后几个元素扩容后索引不变，则节点无需复制
-
-
扩容时并发 put：
-
如果 put 的线程与扩容线程操作的链表是同一个，put 线程会阻塞
-
如果 put 的线程操作的链表还未迁移完成，即头节点不是 ForwardingNode，则可以并发执行
-
如果 put 的线程操作的链表已经迁移完成，即头结点是 ForwardingNode，则可以协助扩容
-
【注意】
- JDK1.7是饿汉式初始化，JDK1.8是懒汉式初始化
- 查看JDK1.8中的ConcurrentHashMap的源码，capacity 代表预估的元素个数，capacity / factory 来计算出初始数组大小，需要贴近 2的n次方
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}-
loadFactor 只在计算初始数组大小时被使用，之后扩容固定为 3/4
-
超过树化阈值时的扩容问题，如果容量已经是 64，直接树化，否则在原来容量基础上做 3 轮扩容
八、 ThreadLocal
1.作用
- ThreadLocal可以实现【资源对象】的线程隔离，让每个线程各用各的【资源对象】，避免争用引发的线程安全问题
- ThreadLocal同时实现了线程内的资源共享
2.原理
在Thread类中定义了一个threadLocals的变量，用来表示当前线程所特有的资源。这里为了方便理解，跟着源码走一下：
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;可以看的出来，在ThreadLocal类中定义了threadLocals的变量的类型ThreadLocalMap
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
同时，ThreadLocalMap中还提供了set、get、remove方法
set方法主要是进行ThreadLocalMap的初始化，并将其绑定到Thread.threadLocals变量上，从而将传入的值绑定到当前线程上。将当前线程作为key，传入的值为value存入到ThreadLocalMap中：
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}get方法主要是将当前线程作为key传入，从Thread.threadLocals变量中获取与当前线程绑定的资源：
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}remove方法主要是将当前线程作为key，移除Thread.threadLocals变量中与当前线程绑定的资源：
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}3.ThreadLocalMap特点
- key 的 hash值统一分配
- 初始容量为16，扩容因子为2/3，扩容容量翻倍
- key索引冲突后用开放寻址法解决冲突
【补充】开放寻址法：解决哈希冲突的一种办法，它和拉链法有所相似，只是处理冲突的方式不一样。拉链法通过在冲突位置开链表解决，开放寻址法通过往后顺次找空位置解决
4.ThreadLocalMap中Key的设计
ThreadLocalMap中的Key被设计为弱引用，原因如下：
Thread可能需要长时间运行（如线程池中的线程），如果Key不再使用，需要在内存不足时释放占用的内存
5.内存释放时机
-
被动 GC 释放 key：
-
仅是让 key 的内存释放，关联 value 的内存并不会释放
-
-
懒惰被动释放 value：
-
get key 时，发现是 null key，则释放其 value 内存
-
set key 时，会使用启发式扫描，清除临近的 null key 的 value 内存，启发次数与元素个数，是否发现 null key 有关
-
-
主动 remove 释放 key，value：
-
会同时释放 key，value 的内存，也会清除临近的 null key 的 value 内存
-
推荐使用它，因为一般使用 ThreadLocal 时都把它作为静态变量（即强引用），因此无法被动依靠 GC 回收
-
3832
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
