多线程-高阶（策略锁、CAS、JUC、ConcurrentHashMap）

1.常见的策略锁

（1）乐观锁

乐观锁：它认为一般情况下不会出现问题，所以他在使用的时候不会加锁，只有在数据修改的时候才会判断有没有锁竞争，如果没有就会直接修改数据，如果有则会返回失败信息给用户处理。

（2）悲观锁

悲观锁：悲观锁任务只要执行多线程就会出现问题，所以在进入方法之后就会直接加锁。

悲观锁的实现：synchronized 可参考

（3）公平锁和非公平锁

• 公平锁：获取锁的顺序按照线程的访问的先后顺序获取。new ReentrantLocak(true)—>设置公平锁
• 非公平锁：不会按照线程的先后访问顺序按需获取。（性能比较高，Java锁设计里面的默认策略）

（4）独占锁和共享锁

• 独占锁：指的是这一把锁只能被一个线程拥有。（synchronized）
• 共享锁：指的是一把锁可以被多个线程同时拥有。（ReadWriterLock读写锁）优势：将锁的粒度更加细化，从而提高锁的性能。

（5）可重入锁

• 可重入锁：一个线程在拥有了一把锁之后，可以重复的进入，就叫做可重入锁。
• 可重入锁的经典代表：synchronized 、ReentrantLock
  

（6）自旋锁

自旋锁：相当于死循环，一直循环尝试获取锁。（synchronized）

（7）偏向锁

偏向锁：在线程初次访问的时候，将线程的ID放到对象头偏向锁ID的字段中，每次访问时判断一下线程的id是否等于对象头中的偏向锁id，如果相等则表明这个线程拥有此锁就可以正常执行代码，否则表明线程不拥有此锁，只能通过自旋的方式尝试获取锁。

2.乐观锁的经典实现：CAS

CAS（Compare　And　Swap）对比并且替换。

（１）CAS实现

• （V【内存中的值】，A【预期的旧值】，B【新值】）
• V＝＝A对比？true－＞Ｖ＝Ｂ：false－＞不能修改
  

（２）CAS的实现原理

CAS在Java中是通过Unsafe实现，Unsafe本地类和本地方法，它是C／C＋＋实现的原生方法，通过调用操作系统的 Atomic::cmpxchg（原子指令）来实现。

（３）CAS在Java中的应用

CAS在Java中的应用：AtomicInteger／Atomic＊

（４）面试题：CAS存在ABA问题，如何处理

• 答：使用版本号，每次修改的时候判断预期的旧值和版本号，每次成功修改之后更改版本号，这样即使预期的值和V值相等，但因为版本号的不同，所以就不能进行修改，从而解决了ABA问题。
• 解决方案：AtomicStampedReference（解决ABA问题）
  里面的旧值它对比的是引用
• AtomicReference（存在ABA问题）

３.JUC

（１）ReentrantLock（可重入锁）

１.lock一定要放在try之前。
２．在finally一定要释放锁。

（２）Semaphore（信号量）

使用步骤：

public class SemaphoreTest {    
    // 最多 5 个坑
    private static final Semaphore avialable = new Semaphore(5);  
    
    public static void main(String[] args) {    
        ExecutorService pool = Executors.newFixedThreadPool(10);    
        Runnable r = new Runnable() {    
            public void run(){    
                try {    
                    avialable.acquire();    //此方法阻塞    
                    Thread.sleep(10 * 1000);    
                    System.out.println(Thread.currentThread().getName());    
                    avialable.release();    
               } catch (InterruptedException e) {    
                    e.printStackTrace();    
               }    
           }    
       };
        for(int i=0;i<10;i++){    
            pool.execute(r);    
       }   
        pool.shutdown();    
   }   
}

（３）CyclicBarrier（循环屏障）

CyclicBarrier执行原理：内有一个计数器，每次线程执行到await方法的时候，计数器＋１，直到计数器个数等于创建时声明的格式的时候，就会突破屏障，执行之后的代码，在突破屏障之后计数器清零可以进行下一轮的执行了。

（４）CountDownLatch（计数器）

• CountDownLatch执行原理：就是内有一个计数器，当执行了countDown，计数器－１，直到减到０那么这个计数器就是用完了，就执行await之后的代码了
• 缺点：计数器只能使用一次

（５）CyclicBarrier和CountDownLatch区别

CountDownLatch它的计数器只能使用一次，CyclicBarrier可以反复使用。

４.HashMap的安全版本：ConcurrentHashMap

HashMap是线程非安全的
HashTable－＞线程安全的（整体给对象加锁）

（１）ConcurrentHashMap实现线程安全的原理

• 在进行修改操作的时候（put），会在进入方法之后加锁，并且在操作完成后释放锁，所以不会有线程安全的问题。

（２）ConcurrentHashMap优化

• 是将HashMap分成多个sengment（字段）对每个sengment分别进行加锁，这样就可以保证多线程如果操作的不是同一个sengment就不需要进行排队处理了，从而提高了程序的执行效果、
• 分段锁：锁粒度更小，性能更高。