Mark World，记录了对象和锁有关的信息

指向类的指针

数组长度（如果当前对象是数组）

简单来说在JVM中monitorenter和monitorexit字节码依赖于底层的操作系统的Mutex Lock来实现的，但是由于使用Mutex Lock需要将当前线程挂起并从用户态切换到内核态来执行，这种切换的代价是非常昂贵的。所以就出现了锁升级的机制

锁在升级到重量锁之前，是不需要进行状态切换的

JDK1.6开始对synchronized做了优化，通过上文讲的Mark World 来区分了不同场景下同步锁的不同类型，来减少线程切换的次数

偏向锁的作用

什么时候升级成轻量级锁

重量级锁

总结

在线程执行到第1处，代码读取到instance不为null时，instance引用的对象有可能还没有完成初始化

instance = new Instance();
分解为如下的3行伪代码

不允许2和3重排序

基于volatile的解决方案

正常的初始化要优于延迟初始化。如果确实需要对实例字段使用线程安全的延迟初始化，请使用基于volatile的延迟初始化的方案；

允许2和3重排序，但不允许其他线程“看到”这个重排序

基于类初始化的解决方案

在执行类的初始化期间，JVM会去获取一个锁.这个锁可以同步多个线程对同一个类的初始化。

如果确实需要对静态字段使用线程安全的延迟初始化，请使用基于类初始化的方案

中断向量表，包括GDT（一个表，描述那些是内核和用户空间），IDT中断号（根据中断号，做进程调度，调度活动队列，阻塞队列）

内存相当于一个线性地址空间，线型数组，内核空间也是在内存里的，但是内核空间是有一个保护模式

时钟中断后在IDT里做进程调度

首先hashmap扩容分为两步

单线程情况下，将原链表1->2->3倒叙插入到新扩容链表3->2->1（如果在扩容后还存在于table相同下标的链表中，这也太巧了，可以买彩票了）

多线程情况下，单链表的头插法，同一位置上新元素总会被放在链表的头部位置，源码中看出，会导致生成环型链表，也就是有可能1的next又指向3了

数组中每个元素进行put都是有一个不同的锁，如果两个线程都是在数组[5]这个位置进行put，这个时候，对数组[5]这个位置进行put的时候，采取的是CAS策略

如果很多个线程对数组中不同位置的元素进行操作，大家是互相不会影响的

如果多个线程对同一个位置进行操作，产生冲突，CAS失败的线程，就会在这个位置基于链表+红黑树来进行处理，synchronized([5]),进行加锁。

线程2会看一下，是不是自己之前加的锁啊？如果不是，此时就是加锁失败。

线程2会将自己放入AQS中的一个等待队列

如果是自己之前加的锁，将aqs里面的state加1。

将AQS内的state变量的值递减1，如果state值为0，则彻底释放锁

将“加锁线程”变量也设置为null

从等待队列的队头唤醒线程2重新尝试加锁

默认：AbortPolicy：丢弃任务并抛出RejectedExecutionException异常，比较关键的业务，推荐使用此拒绝策略

DiscardPolicy：丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，无关紧要的业务采用此策略。例如，博客网站统计阅读量就是采用的这种拒绝策略

DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务，根据实际业务是否允许丢弃老任务来认真衡量。

CallerRunsPolicy：由调用主线程处理该任务

对volatile修饰的变量，执行写操作的话，JVM会发送一条lock前缀指令给CPU，CPU在计算完之后会立即将这个值写回主内存，同时因为有MESI缓存一致性协议，所以各个CPU都会对总线进行嗅探，自己本地缓存中的数据是否被别人修改

如果发现别人修改了某个缓存的数据，那么CPU就会将自己本地缓存的数据过期掉，然后这个CPU上执行的线程在读取那个变量的时候，就会从主内存重新加载最新的数据了

对于volatile修改变量的读写操作，都会加入内存屏障

每个volatile写操作前面，加StoreStore屏障，禁止上面的普通读写和他重排；每个volatile写操作后面，加StoreLoad屏障，禁止跟下面的volatile读/写重排

每个volatile读操作后面，加LoadLoad屏障，禁止下面的普通读和voaltile读重排；每个volatile读操作后面，加LoadStore屏障，禁止下面的普通写和volatile写重排

原理：ThreadLocal，连接ThreadLocalMap和Thread。来处理Thread的TheadLocalMap属性，包括init初始化属性赋值、get对应的变量，set设置变量等。通过当前线程，获取线程上的ThreadLocalMap属性，对数据进行get、set等操作

源码分析：
public T get() {
   //获取当前线程，线程互不干扰的操作ThreadLocal的原因就是，它的set、get方法是要先获取当前线程，然后修改、操作这个线程对象的成员属性
   Thread t = Thread.currentThread();
   //ThreadLocalMap 是一个静态内部类，getMap方法返回的就是当前线程的变量threadLocals
   ThreadLocalMap map = getMap(t);
  //初始threadLocals是null，调用set方法以后才会有值
   if (map != null) {
         //ThreadLocalMap有个静态内部类Entry，key是ThreadLocal，值是我们自己设定的maBaoGuo，即类型是当初定义ThreadLocal类型的变量时，泛型的类型。且这个Entry还是个弱引用
        ThreadLocalMap.Entry e = map.getEntry(this);//this就是ThreadLocal对象本身
        if (e != null) {
           @SuppressWarnings("unchecked")
           T result = (T)e.value;
           //把变量maBaoGuo就返回了
           return result;
        }
    }
    //初始化操作，返回null的同时，里面会给当前线程Thread的变量threadLocals赋值new ThreadLocalMap(this, firstValue);，这个threadLocals变量的类型是ThreadLocal.ThreadLocalMap，再强调下，threadLocals是thread类里面的变量。
    return setInitialValue();
}

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
    //注意，value 当前为null
    createMap(t, value);
    return value;
}

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

假如set语句是，maBaoGuo.set(new HashMap<>());

源码分析：
public void set(T value) {
   Thread t = Thread.currentThread();
   ThreadLocalMap map = getMap(t);
   if (map != null)
      map.set(this, value);//this是对象本身
   else
   createMap(t, value);
}

private void set(ThreadLocal<?> key, Object value) {
//table表示每个线程里有多个ThreadLocal变量
Entry[] tab = table;
int len = tab.length;
//找到通过key找到当前threadlocal在entry[]中的下标位置
int i = key.threadLocalHashCode & (len-1);
//因为存储到table时，可能发生碰撞，set时的解决方案是找下一个下标中有没有值，如果没有就利用，所以会在此处用for循环去遍历，而不一定直接利用计算出来的下标就能找到你想要的entry（上面说过ThreadLocalMap有个静态内部类Entry，key是ThreadLocal）
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//代表从table里找到了entry，直接替换
if (k == key) {
e.value = value;
return;
}
//如果==null，说明这个位置还没人用，直接set
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}

tab[i] = new Entry(key, value);
int sz = ++size;
//如果没找到位置，说明已经空间不足，这时候对table进行扩容生成新的 Entry[]，且重新rehash
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}

假如定义：ThreadLocal<Map<String,Integer>> REENTRANT_LOCAL_MAP = new ThreadLocal<>();

当第一次加锁时，在Threadlocal对象里新建TreadLocalMap，并且赋值value，代码：REENTRANT_LOCAL_MAP.set(new HashMap<>());

判断当前加锁次数：Integer reentrantCount = REENTRANT_LOCAL_MAP.get().getOrDefault(key,0);

判断当前加锁次数：Integer reentrantCount = REENTRANT_LOCAL_MAP.get().get(key);

首先这个跟可重入没关系，这是分布式锁要考虑的。顺便写一下

加锁的时候把uuid存到redis的value里，解锁时判断传参是否和redis中存的value一致，达到的目的就是保证线程自己加的锁，自己解锁，防止别的线程来解自己的锁

用treadID会保证唯一吗？理论上不会，因为多台服务器之间创建的线程id有可能重复。因为线程id不能保证全局唯一

public int await()：用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任
务

public int await(long timeout, TimeUnit unit)：让这些线程等待至一定的时间，如果还有
线程没有到达 barrier 状态就直接让到达 barrier 的线程执行后续任务

java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作

使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效

Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()

BlockingQueue通常用于一个线程生产对象，另外一个线程消费这些对象的场景

对应的方法中都使用了锁, 所以不会出现线程安全问题

插入

移除

元素检查

阻塞队列

实现类

CountDownLatch以一个给定的数量初始化，countDown()每被调用一次，这一数量就减一，通过调用await()方法，线程可以阻塞等待这一数量到达零

就是一个所有线程必须等待的栅栏，所有(一定数量的)线程等待栅栏CyclicBarrier达成，所有线程将释放掉继续运行

Executor

ExecutorService 接口表示一个异步执行机制，使我们能够在后台执行任务

 ExecutorService 实现就是一个线程池实现

ExecutorService扩展类

Executors提供的线程池配置方案

execute(Runnable)方法要求一个java.lang.Runnable对象，然后对它进行异步执行

submit(Runnable)也要求一个Runnable实现类，返回一个Future对象用来检查Runnable是否已经执行完毕

ExecutorService executorService = Executors.newSingleThreadExecutor();
     executorService.execute(new Runnable() {
           public void run() { System.out.println("Asynchronous task"); }
      });
executorService.shutdown();

创建线程一般有两种方式，一种是继承Thread类，一种是实现Runnable接口。然而，这两种方式的缺点是在线程任务执行结束后，无法获取执行结果

Java中，也提供了使用Callable和Future来实现获取任务结果的操作。Callable用来执行任务，产生结果，而Future用来获得结果。

class AddNumberTask implements Callable<Integer> {
    public AddNumberTask() {
    }
@Override
public Integer call() throws Exception {
      System.out.println("####AddNumberTask###call()");
      Thread.sleep(5000);
      return 5000;
}

Callable接口

Futrue接口

区别

实现类ReentrantLock

方法

实现类ReentrantReadWriteLock

ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
ReadLock rl = readWriteLock.readLock();
WriteLock wl = readWriteLock.writeLock();

AtomicBoolean atomicBoolean = new AtomicBoolean(); //默认false

AtomicInteger atomicInteger = new AtomicInteger();  //默认为0

AtomicReference