java语言中的锁

1. 从java的集合线程安全开始说起
   1. 平时经常使用的集合类如ArrayList,LinkedList,HashSet等以及Map都是线程不安全的，如果进行多线程操作会出现线程安全问题，那么java是如何解决这些常用类的线程安全问题呢
   2. 几个常用的保证集合类线程安全的方法
      1. 使用synchronized关键字
      2. 使用Collections提供的工具方法保证线程安全，底层还是使用Synchronized关键字

         Collections.synchronizedCollection(list)
         Collections.synchronizedList()
         Collections.synchronizedSet();
         Collections.synchronizedMap();

      3. 使用juc包中的提供的集合类：

         CopyOnWriteArrayList
         CopyOnWriteArraySet
         ConcurrentHashMap

         copyOnWrit类在新增元素的时候，会将add方法加锁，防止其他线程调用add方法时产生线程不安全问题。在加锁后，回将底层保存元素的数组copy一份，并利用这个拷贝的副本创建一个新的数组，然后将要追加的元素放到新数组中, 最后保存元素的数组指向包含要追加元素的新数组,然后解锁

2. 使用锁和synchronized来保证线程安全的对比

   1. 原始构成
      1. synchronized是java的关键字，是在jvm层面的实现，底层利用moniter实现
         1. jvm层面在进入被synchronized块包围的代码块是执行 moniterenter命令，跳出时执行moniterexit命令
      2. lock是在语言层面的实现，它是在jdk5之后新出现的一个java类
   2. 使用方法
      1. 使用synchronized关键字不需要用户手动释放锁，即使代码出现异常锁也会被释放
      2. 使用lock需要手动释放锁，否则会出现死锁情况；配合try--catch-finally代码块使用lock，unlock加锁，释放锁
   3. 等待是否可中断
      1. synchronized的不能被中断，一旦进入synchronized代码块，代码要不正常执行完，要么出现异常跳出代码块
      2. 使用lock可以出现中断
   4. 是否是公平锁
      1. synchronized为非公平锁
      2. lock可以是公平锁也可以是非公平锁，默认是非公平锁
   5. 锁绑定多个条件condition
      1. lock可以实现分组唤醒，可以精确唤醒需要唤醒的线程，而synchronized要么唤醒一个线程要么唤醒全部线程，无法精确控制 lock绑定多条件示例代码见 iqijun/javastudy
3. java中锁的分类
   1. 公平锁和非公平锁
      1. 公平锁是指按申请锁的顺序来获得锁
      2. 非公平锁是指随机抢占锁，而不是按照顺序获得
      3. 非公平锁可能会造成优先级反转问题和饥饿现象（线程长时间获取不到锁），但非公平锁的吞吐量比较大
      4. ReentrantLock默认为非公平锁，synchronized也是非公平锁
   2. 可重入锁（递归锁）
      1. 可重入锁是指当线程获得了外层方法的锁之后，也可以进入到需要相同锁的内部方法。而不需要在进入到内部方法时重新获取锁。
      2. 比如

         /**
          * @program: course
          * @description: 重入锁演示
          * 重入锁又叫递归锁，当线程在外城方法中获得到锁以后，它边默认可以进入到需要相同锁的内部方法中
          * 如示例中methodA和methodB都需要获得lock，当线程在进入到methodA中时获取到lock，那边它便可以顺利进入到methodB中
          * 而不需要在进入到methodB的时候重新获取锁
          * @author: xingguishuai
          * @create: 2019-05-25 14:45
          */
         public class ReentredLockDemo {
         
             Lock lock  = new ReentrantLock();
         
             public static  void main(String[] args){
                final   ReentredLockDemo reentredLockDemo = new ReentredLockDemo();
                 for (int i = 0; i < 10; i++) {
                     new Thread(new Runnable() {
                         @Override
                         public void run() {
                             reentredLockDemo.methodA();
                         }
                     },"Thread_"+i).start();
                 }
             }
         
         
             public void methodA(){
                 lock.lock();
                 try {
                     System.out.println(Thread.currentThread().getName()+"进入mthodA,获得到锁");
                     methodB();
                 }catch (Exception e){
         
                 }finally {
                     lock.unlock();
                 }
         
             }
         
             public  void methodB(){
                 lock.lock();
                 try {
                     System.out.println(Thread.currentThread().getName()+"进入mthodB,获得到锁");
                 }catch (Exception e){
         
                 }finally {
                     lock.unlock();
                 }
             }
         
         }
         

      3. 可重入锁的好处是可以有效避免死锁现象。这是因为减少了锁抢占

      4. ReentrantLock,synchronized都是可重入锁

   3. 独享锁、共享锁

      1. 独享锁是指该锁一次只能被一个线程所持有。共享锁是指该锁可被多个线程所持有。

         ReentrantLock,synchronized都是独享锁，ReadWriteLock的readLock是共享锁

         1. 共享锁和不加锁的区别

         加的共享锁之后，就不能再次加独享锁。可以实现多条线程去读，但读的同时不能有写操作

   4. 自旋锁

      自旋锁是指在线程获取锁不成功的时候，不会将线程阻塞，而是通过不断的重试来获取锁.

      自旋锁的好处是减少了线程上下文切换的消耗

      但由于自旋锁通过循环不停的尝试获取锁，会造成cpu的消耗

4. java中锁的实现原理

java中锁是完全利用java语言实现的，它的实现利用了cas原理和AbstractQueuedSynchronizerl类