并发编程体系-管程

1. 临界区：一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

2. 并发访问的线程安全问题
   多个线程对共享资源进行读写的时候发生指令错乱，比如当A线程对i进行修改，但还未修改时间片就执行完，此时保存当前状态，而B线程对i进行了修改保存后，轮到A执行，A将他的未写入i写入，导致最后结果为A修改的值

3. Synchronized
   1. synchronized语法：synchronized(对象) // 线程1， 线程2(blocked) { 临界区 }
   2. synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的⽅法或者代码块在任意时刻只能有⼀个线程执⾏。
   3. synchronized的三种方式：
   1. 修饰实例⽅法: 作⽤于当前对象实例加锁，进⼊同步代码前要获得当前对象实例的锁
   2. 修饰静态⽅法: 也就是给当前类的Class对象加锁，会作⽤于类的所有对象实例，进入同步代码之前要获得当 前 class 的锁，因为静态成员不属于任何⼀个实例对象，是类成员，所以，如果⼀个线程 A 调⽤⼀个实例对象的⾮静态 synchronized ⽅法，⽽线程 B 需要调⽤这个实例对象所属类的静态 synchronized ⽅法，是允许的，不会发⽣互斥现象，因为访问静态 synchronized ⽅法占⽤的锁是当前类的锁，⽽访问⾮静态 synchronized ⽅法占⽤的锁是当前实例对象锁。
   3. 修饰同步代码块: 指定加锁对象，对给定对象加锁，进⼊同步代码库前要获得给定对象的锁。
   4. Synchronized的工作原理：
   1. Synchronized修饰同步代码块 ：synchronized 同步语句块的实现使⽤的是 monitorenter 和 monitorexit 指令，其中 monitorenter指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。 当执⾏monitorenter 指令时，线程试图获取锁也就是获取 monitor的持有权。当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执⾏monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外⼀个线程释放为⽌。
   2.Synchronized修饰方法：synchronized 修饰的⽅法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是ACC_SYNCHRONIZED 标识，该标识指明了该⽅法是⼀个同步⽅法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别⼀个⽅法是否声明为同步⽅法，从⽽执⾏相应的同步调⽤。

4. 线程安全分析
   1. 成员变量和静态变量是否线程安全？
   如果没有被共享，就是安全的。如果被共享了，只有读操作，那是安全的；如果是读写操作同时，那需要考虑线程安全问题
   2. 局部变量安全分析
   1. 如果是多个线程调用某个方法的局部变量，每个线程会在自己的栈中创建，不会被共享
   2. 如果是多个线程调用类的成员变量，就会出现并发安全问题。这是可以把这个变量改为局部变量
   3. 线程安全常见类：

    	String、Integer、StringBuffer、Random、Vector、Hashtable、java.util.concurrent 包下的类
   

5. Monitor（监视器/管程）
   每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针，如果其他线程想访问同一个对象，那么就加入到Monitor的EntryList中去阻塞等待。
   
   
   注意事项： synchronized 必须是进入同一个对象的 monitor 才有上述的效果，不加 synchronized 的对象不会关联监视器

6. 轻量级锁
   轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。
   轻量级锁的加锁过程：
   1. 创建锁记录（Lock Record）对象，每个线程的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
   2. 创建Mark Word的拷贝Displace Mark Word，让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录
   
   3. 如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 ，表示由该线程给对象加锁
   4. 如果 cas 失败，有两种情况：1.如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程。2.如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数，当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
   
   5. 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头成功，则解锁成功失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

7. 锁膨胀
   过程：如果有其他线程对对象已经加上轻量级锁，那么其他线程在尝试加轻量级锁时，发生CAS操作失败，这时候就需要锁膨胀，将轻量级锁升级为重量级锁，其他线程为object对象申请Monitor锁，让object指向重量级锁地址，然后自己进入 Monitor 的 EntryList BLOCKED。
   
   当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程

8. 自旋锁
   自旋锁是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。自旋锁是重量级锁优化竞争的一个方式
   自旋锁的问题：

    1. 如果某个线程持有锁的时间过长，就会导致其它等待获取锁的线程进入循环等待，消耗CPU。**使用不当会造成CPU使用率极高。**
    2. 无法满足等待时间最长的线程优先获取锁，造成**线程饥饿**问题
   

   自旋锁优点：自旋锁不会使线程状态发生切换，一直处于用户态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换，执行速度快

9. 偏向锁
   轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。所以引入了偏向锁进行优化
   1. 偏向锁的目标：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID 是自己的就表示没有竞
   争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有。
   2. 正常状态是Mark Word头后三位是001，开启了偏向锁的后三位是 101，

   3. 怎么撤销偏向锁：
      1. 调用对象的hashcode方法，因为偏向锁对象的MarkWord中存储的是线程的id，当对象调用hashcode方法后，原本放线程Id的位置需要用来存放hashcode
      2. 当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁
      3. 调用wait和notify，wait/notify只有重量级锁有
   4. 偏向锁的批量重偏向和批量撤销
      1. 批量重偏向：当对象虽然被多个线程访问，但没有竞争，这是偏向线程T1的对象仍然有机会偏向T2线程，重偏向会重置对象的ThreadID ,当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至
      加锁线程
      2. 批量撤销：当撤销偏向锁阈值超过 40 次后，jvm 会觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象
      都会变为不可偏向的，新建的对象也是不可偏向的

10. 锁消除：编译器会清除一些使用了同步，但同步块中没有涉及共享数据的锁，从而减少多余的同步

11. 锁粗化：若有一系列操作反复地对同一把锁进行上锁和解锁操作，编译器会扩大这部分代码的同步块的边界，从而只使用一次上锁和解锁操作。

12. wait/notify工作原理
    

    1. Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
    2. BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片，BLOCKED 线程会在 Owner 线程释放锁时唤醒
    3. WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入EntryList 重新竞争

13. join方法的原理

    	1. join(n)方法会首先检查输入的时间n是否合理，如果合理，判断当前线程是否存活（isAlive），如果存活就内部调用wait(m)来等待结束。
    	2. join()的方法其实就是join(0)
    

14. park()/unpark(Thread t)方法
    1. 每个线程都有一个自己的paker对象，对象中有counter、cond、mutex三个对象
    2. park原理（看上图）
    1.调用park首先检查counter是不是为0，如果为0，获得mutex互斥锁，把线程阻塞在cond中，然后再将counter设置为0
    2.如果counter不是为0，线程就继续运行
    3. unpark的原理
    

    		1. 首先将counter设置为1，如果cond中有线程则唤醒cond中的线程，线程恢复运行，再将counter设置为0.
    

    3. 先调用unpark再调用park为什么不会阻塞？
       调用unpark（），将counter设置为1，当前线程调用park，检查counter，这种情况counter=1，不需要阻塞线程，继续运行，将counter改为0

15. 死锁
    1. 什么是死锁？多个线程同时被阻塞，它们中的⼀个或者全部都在等待某个资源被释放。由于线程被⽆限期地阻塞，因此程序不可能正常终⽌。（线程A等待B释放资源，B等待A释放资源）

    	2. 形成死锁的四个条件：
    			1.  互斥条件：该资源任意⼀个时刻只由⼀个线程占⽤。
    			2.  请求与保持条件：⼀个进程因请求资源⽽阻塞时，对已获得的资源保持不放。
    			3. 不剥夺条件:线程已获得的资源在末使⽤完之前不能被其他线程强⾏剥夺，只有⾃⼰使⽤完毕后才释放资源。
    			4. 循环等待条件:若⼲进程之间形成⼀种头尾相接的循环等待资源关系。
    	3. 如何避免死锁：
    			1.  破坏互斥条件 ：临界资源需要互斥访问，但是这个条件无法破坏，临界区就是用来互斥的。
    			2. 破坏请求与保持条件 ：⼀次性申请所有的资源。
    			3. 破坏不剥夺条件 ：占⽤部分资源的线程进⼀步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
    			4. 破坏循环等待条件 ：靠按序申请资源来预防。按某⼀顺序申请资源，释放资源则反序释放。
    

16. 活锁：两个线程互相改变对方的结束条件，最后谁也无法结束（A线程要counter减到0，B线程要Counter超过10，两个线程互相修改导致都无法结束）

17. 饥饿：一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束