并发安全工具类（2）：干变万化的锁

我会带着你远行 2023-07-02 03:23 5阅读 0赞

>  *  synchronized：不可中断锁，适合竟争不激烈，可读性好
>  *  Lock：可中断锁，多样化同步，竞争激烈时能维持常态
>  *  Atomic：竞争激烈时能维持常态，比Lock性能好；只能同步一个值

--------------------

# 1 Lock接口 #

> Lock：依赖特殊的CPU指令

> 简介、地位、作用
> 
>  *  锁是一种工具，用于控制对共享资源的访问。
>  *  Lock和synchronized这两个是最常见的锁，它们都可以达到线程安全的目的，但是在使用上和功能上又有较大的不同。
>  *  Lock并不是用来代替synchronized的，而是当使用synchronized不合适或不足以满足要求的时候，来提供高级功能的。
>  *  Lock接口最常见的实现类是ReentrantLock。
>  *  通常情况下，Lock只允许一个线程来访问这个共享资源。不过有的时候，一些特殊的实现也可允许并发访问，比如ReadWriteLock里面的ReadLock。
> 
> --------------------
> 
> 为什么synchronized不够用？为什么需要Lock？
> 
>  *  效率低：锁的释放情况少、试图获得锁时不能设定超时、不能中断一个正在试图获得锁的线程。
>  *  不够灵活（读写锁更灵活）：加锁和释放的时机单一，每个锁仅有单一的条件（某个对象），可能是不够的。
>  *  无法知道是否成功获取到锁。

> 主要方法介绍
> 
>  *  在Lock中声明了四个方法来获取锁（lock()、tryLock()、tryLock(long time, TimeUnit unit)、lockInterruptibly()）。
> 
> --------------------
> 
> lock()
> 
>  *  lock()就是最普通的获取锁。如果锁已被其他线程获取，则进行等待。
>  *  Lock不会像synchronized一样在异常时自动释放锁。
>  *  因此最佳实践是，在finally中释放锁，以保证发生异常时锁一定被释放。
>  *  lock()方法不能被中断，这会带来很大的隐患：一旦陷入死锁，lock()就会陷入永久等待。
> 
> --------------------
> 
> tryLock()
> 
>  *  tryLock()用来尝试获取锁，如果当前锁没有被其他线程占用，则获取成功，则返回true，否则返回false，代表获取锁失败。
>  *  相比于lock，这样的方法显然功能更强大了，我们可以根据是否能获取到锁来决定后续程序的行为。
>  *  该方法会立即返回，即便在拿不到锁时不会一直在那等。
> 
> --------------------
> 
> tryLock(long time, TimeUnit unit)
> 
>  *  tryLock(long time, TimeUnit unit)：超时就放弃
> 
> --------------------
> 
> lockInterruptibly()
> 
>  *  lockInterruptibly()：相当于tryLock(long time, TimeUnit unit)把超时时间设置为无限。在等待锁的过程中，线程可以被中断。
> 
> --------------------
> 
> unlock()
> 
>  *  unlock()：解锁

/**
     * Lock不会像synchronized一样，异常的时候自动释放锁，所以最佳实践是，finally中释放锁，以便保证发生异常的时候锁一定被释放
     */
    public class MustUnlock {
        private static Lock lock = new ReentrantLock();
        public static void main(String[] args) throws InterruptedException {
            Runnable run = ()->{
                lock.lock();
                try {
                    //获取本锁保护的资源
                    System.out.println(Thread.currentThread().getName() + "开始执行任务");
                    int a = 1 / 0;
                } finally {
                    //注释后，其他线程无法获得这个锁了
                    lock.unlock();
                }
            };
            new Thread(run).start();
            Thread.sleep(1000);
            new Thread(run).start();
        }
    }

/**
     * 用tryLock来避免死锁
     */
    public class TryLockDeadlock implements Runnable {
        static Lock lock1 = new ReentrantLock();
        static Lock lock2 = new ReentrantLock();
        public static void main(String[] args) {
            TryLockDeadlock r1 = new TryLockDeadlock();
            TryLockDeadlock r2 = new TryLockDeadlock();
            new Thread(r1, "A").start();
            new Thread(r2, "B").start();
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if ("A".equals(Thread.currentThread().getName())) {
                    try {
                        if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
                            try {
                                System.out.println("线程A获取到了锁1");
                                Thread.sleep(new Random().nextInt(1000));
                                if (lock2.tryLock(800, TimeUnit.MILLISECONDS)) {
                                    try {
                                        System.out.println("线程A获取到了锁2");
                                        System.out.println("线程A成功获取到了两把锁");
                                        break;
                                    } finally {
                                        lock2.unlock();
                                    }
                                } else {
                                    System.out.println("线程A获取锁2失败，已重试");
                                }
                            } finally {
                                lock1.unlock();
                                Thread.sleep(new Random().nextInt(1000));
                            }
                        } else {
                            System.out.println("线程A获取锁1失败，已重试");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
                if ("B".equals(Thread.currentThread().getName())) {
                    try {
                        if (lock2.tryLock(3000, TimeUnit.MILLISECONDS)) {
                            try {
                                System.out.println("线程B获取到了锁2");
                                Thread.sleep(new Random().nextInt(1000));
                                if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
                                    try {
                                        System.out.println("线程B获取到了锁1");
                                        System.out.println("线程B成功获取到了两把锁");
                                        break;
                                    } finally {
                                        lock1.unlock();
                                    }
                                } else {
                                    System.out.println("线程B获取锁1失败，已重试");
                                }
                            } finally {
                                lock2.unlock();
                                Thread.sleep(new Random().nextInt(1000));
                            }
                        } else {
                            System.out.println("线程B获取锁2失败，已重试");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

public class LockInterruptibly implements Runnable {
        private Lock lock = new ReentrantLock();
        public static void main(String[] args) {
            LockInterruptibly lockInterruptibly = new LockInterruptibly();
            Thread thread0 = new Thread(lockInterruptibly,"A");
            Thread thread1 = new Thread(lockInterruptibly,"B");
            thread0.start();
            thread1.start();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            thread1.interrupt();
        }
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "尝试获取锁");
            try {
                lock.lockInterruptibly();
                try {
                    System.out.println(Thread.currentThread().getName() + "获取到了锁");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    System.out.println(Thread.currentThread().getName() + "睡眠期间被中断了");
                } finally {
                    lock.unlock();
                    System.out.println(Thread.currentThread().getName() + "释放了锁");
                }
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "获得锁期间被中断了");
            }
        }
    }

> 可见性保证
> 
>  *  happens-before：[https://blog.csdn.net/qq\_40794973/article/details/103960056\#t9][https_blog.csdn.net_qq_40794973_article_details_103960056_t9]
>  *  Lock的加解锁和synchronized有同样的内存语义，也就是说，下一个线程加锁后可以看到所有前一个线程解锁前发生的所有操作。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1][]

--------------------

# 2 锁的分类 #

> 这些分类，是从各种不同角度出发去看的。这些分类并不是互斥的，也就是多个类型可以并存，有可能一个锁，同时属于两种类型。比如ReentrantLock既是互斥锁，又是可重入锁，好比一个人可以同时是男人，又是军人，这个不冲突。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2][]

--------------------

# 3 乐观锁和悲观锁 #

> 为什么会诞生**非互斥同步锁**
> 
>  *  乐观锁：非互斥同步锁
>  *  悲观锁：互斥同步锁
> 
> **互斥同步锁**的劣势
> 
>  *  阻塞和唤醒带来的性能劣势
>  *  永久阻塞：如果持有锁的线程被永久阻塞，比如遇到了无限循环、死锁等活跃性问题，那么等待该线程释放锁的那几个悲催的线程，将永远也得不到执行
>  *  优先级反转

> 什么是乐观锁和悲观锁
> 
>  *  人的性格
>  *  从是否锁住资源的角度分类
> 
> --------------------
> 
> 悲观锁
> 
>  *  如果我不锁住这个资源，别人就会来争抢，就会造成数据结果错误，所以每次悲观锁为了确保结果的正确性，会在每次获取并修改数据时，把数据锁住，让别人无法访问该数据，这样就可以确保数据内容万无一失
>  *  Java中悲观锁的实现就是synchronized和Lock相关类
> 
> --------------------
> 
> 乐观锁
> 
>  *  认为自己在处理操作的时候不会有其他线程来千扰，所以并不会锁住被操作对象
>  *  在更新的时候，去对比在我修改的期间数据有没有被其他人改变过：如果没被改变过，就说明真的是只有我自己在操作，那我就正常去修改数据
>  *  如果数据和我一开始拿到的不一样了，说明其他人在这段时间内改过数据，那我就不能继续刚才的更新数据过程了，我会选择放弃、报错、重试等策略
>  *  乐观锁的实现一般都是利用CAS算法来实现的
>  *  乐观锁的典型例子就是原子类、并发容器等

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4][]

public class PessimismOptimismLock {
        int a;
        //悲观锁
        public synchronized void testMethod() {
            a++;
        }
        public static void main(String[] args) {
            //乐观锁
            AtomicInteger atomicInteger = new AtomicInteger();
            atomicInteger.incrementAndGet();
        }
    }

> 典型例子
> 
> Git
> 
>  *  Git：Git就是**乐观锁**的典型例子，当我们往远端仓库push的时候，git会检査远端仓库的版本是不是领先于我们现在的版本，如果远程仓库的版本号和本地的不一样，就表示有其他人修改了远端代码了，我们的这次提交就失败；如果远端和本地版本号一致，我们就可以顺利提交版本到远端仓库
>  *  Git不适合用悲观锁，否则公司倒闭
> 
> --------------------
> 
> 数据库 
> 
>  *  select for update就是悲观锁
>  *  用version控制数据库就是乐观锁
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5][]

> 开销对比
> 
>  *  悲观锁的原始开销要高于乐观锁，但是特点是一劳永逸，临界区持锁时间就算越来越差，也不会对互斥锁的开销造成影响
>  *  相反，虽然乐观锁一开始的开销比悲观锁小，但是如果自旋时间很长或者不停重试，那么消耗的资源也会越来越多

> 两种锁各自的使用场景：各有干秋
> 
> 悲观锁：适合并发写入多的情况，适用于临界区持锁时间比较长的情况，悲观锁可以避免大量的无用自旋等消耗
> 
> 1.  临界区有IO操作
> 2.  临界区代码复杂或者循环量大
> 3.  临界区竞争非常激烈
> 
> --------------------
> 
> 乐观锁：适合并发写入少，大部分是读取的场景，不加锁能让读取性能大幅提高。

--------------------

# 4 可重入锁和非可重入锁，以ReentrantLock为例（重点） #

> ReentrantLock：自旋锁，通过循环调用CAS操作来实现加锁，避免了使线程进入内核态的阻塞状态，所以性能比较好

> ReentrantLock（可重入锁）和synchronized区别
> 
>  *  可重入性：都可
>  *  锁的实现：synchronized依赖于JVM实现，ReentrantLock是JDK实现的（手动挡和自动挡的区别）
>  *  性能的区别：synchronized经过优化后和ReentrantLock性能差不多，两种方法都可用的情况下官方推荐synchronized
>  *  功能区别：synchronized方便简洁由编译器实现锁的加锁和释放，ReentrantLock需要手动操作；ReentrantLock锁的粒度更细使用更加灵活
> 
> --------------------
> 
> ReentrantLock独有的功能
> 
>  *  可指定是公平锁还是非公平锁（synchronized只能是非公平锁）
>  *  提供了一个Condition类，可以分组唤醒需要唤醒的线程（[https://yuanyu.blog.csdn.net/article/details/104111726\#t11][https_yuanyu.blog.csdn.net_article_details_104111726_t11]）
>  *  提供能够中断等待锁的线程的机制，lock.lockInterruptibly()

> 普通用法1：预定电影院座位

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8][]

/**
     * 演示多线程预定电影院座位
     */
    public class CinemaBookSeat {
        private static ReentrantLock lock = new ReentrantLock();
        private static void bookSeat() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "开始预定座位");
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "完成预定座位");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        public static void main(String[] args) {
            new Thread(() -> bookSeat()).start();
            new Thread(() -> bookSeat()).start();
            new Thread(() -> bookSeat()).start();
            new Thread(() -> bookSeat()).start();
        }
    }

> 普通用法2：打印字符串

/**
     * 演示ReentrantLock的基本用法，演示被打断
     */
    public class LockDemo {
        public static void main(String[] args) {
            new LockDemo().init();
        }
        private void init() {
            final Outputer outputer = new Outputer();
            new Thread(() -> {
                while (true) {
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("蔡徐坤");
                }
    
            }).start();
            new Thread(() -> {
                while (true) {
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("乔碧萝");
                }
    
            }).start();
        }
        static class Outputer {
            Lock lock = new ReentrantLock();
            //字符串打印方法，一个个字符的打印
            public void output(String name) {
                int len = name.length();
                lock.lock();
                try {
                    for (int i = 0; i < len; i++) {
                        System.out.print(name.charAt(i));
                    }
                    System.out.println("");
                } finally {
                    lock.unlock();
                }
            }
        }
    }

> 可重入性质
> 
>  *  什么是可重入：[https://blog.csdn.net/qq\_40794973/article/details/103880263\#t8][https_blog.csdn.net_qq_40794973_article_details_103880263_t8]
>  *  源码对比：可重入锁ReentrantLock以及非可重入锁ThreadPoolExecutor的Worker类

public class GetHoldCount {
        private  static ReentrantLock lock =  new ReentrantLock();
        public static void main(String[] args) {
            System.out.println(lock.getHoldCount());//0
            lock.lock();
            System.out.println(lock.getHoldCount());//1
            lock.lock();
            System.out.println(lock.getHoldCount());//2
            lock.lock();
            System.out.println(lock.getHoldCount());//3
            lock.unlock();
            System.out.println(lock.getHoldCount());//2
            lock.unlock();
            System.out.println(lock.getHoldCount());//1
            lock.unlock();
            System.out.println(lock.getHoldCount());//0
        }
    }

public class RecursionDemo {
        private static ReentrantLock lock = new ReentrantLock();
        private static void accessResource() {
            lock.lock();
            try {
                System.out.println("已经对资源进行了处理");
                if (lock.getHoldCount()<5) {
                    System.out.println(lock.getHoldCount());
                    accessResource();
                    System.out.println(lock.getHoldCount());
                }
            } finally {
                lock.unlock();
            }
        }
        public static void main(String[] args) {
            accessResource();
        }
    }

>  可重入锁和不可重入锁源码对比

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9][]

>  ReentrantLock的其他方法介绍
> 
>  *  isHeldByCurrentThread：可以看出锁是否被当前线程持有
>  *  getQueueLength：可以返回当前正在等待这把锁的队列有多长
> 
> 一般这两个方法是开发和调试时候使用，上线后用到的不多

public class Main {
        private static final ReentrantLock reentrantLock = new ReentrantLock();
        public synchronized void write() {
            try {
                // 加锁解锁要一致
                reentrantLock.lock();
                reentrantLock.lock();
                System.out.println(Thread.currentThread().getName() + " call write.");
                TimeUnit.SECONDS.sleep(3);
                this.red(); //
            } catch (InterruptedException ignored) {
            } finally {
                reentrantLock.unlock();
                reentrantLock.unlock();
            }
        }
        public synchronized void red() {
            try {
                reentrantLock.lock();
                System.out.println(Thread.currentThread().getName() + " call red.");
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException ignored) {
            } finally {
                reentrantLock.unlock();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            Main main = new Main();
            new Thread(main::write, "AAA").start();
            new Thread(main::red, "BBB").start();
            //AAA call write.
            //AAA call red.
            //BBB call red.
        }
    }

--------------------

# 5 公平锁和非公平锁 #

> 什么是公平和非公平
> 
>  *  公平指的是按照线程请求的顺序，来分配锁；非公平指的是**不完全**按照请求的顺序，在一定情况下，可以插队。
>  *  注意：非公平也同样不提倡“插队”行为，这里的非公平，指的是“在合适的时机”插队，而不是盲目插队。
>  *  什么是合适的时机呢？
> 
> --------------------
> 
> 为什么要有非公平锁
> 
>  *  默认策略是非公平
>  *  实际情况并不是这样的，Java设计者这样设计的目的，是为了提高效率
>  *  避免唤醒带来的空档期

> 公平的情况（以ReentrantLock为例）
> 
>  *  如果在创建ReentrantLock对象时，参数填写为true，那么这就是个公平锁
>  *  假设线程1234是按顺序调用lock()的

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10][]

> 不公平的情况（以ReentrantLock为例）
> 
>  *  如果在线程1释放锁的时候，线程5怡好去执行lock()
>  *  由于ReentrantLock发现此时并没有线程持有lock这把锁（线程2还没来得及获取到，因为获取需要时间）
>  *  线程5可以插队，直接拿到这把锁，这也是ReentrantLock**默认**的公平策略，也就是“不公平”

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11][]

> 代码案例：演示公平和非公平的效果

/**
     * 演示公平和不公平两种情况
     */
    public class FairLock {
        public static void main(String[] args) {
            PrintQueue printQueue = new PrintQueue();
            Thread thread[] = new Thread[10];
            for (int i = 0; i < 10; i++) {
                thread[i] = new Thread(new Job(printQueue));
            }
            //顺序启动
            for (int i = 0; i < 10; i++) {
                thread[i].start();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    class Job implements Runnable {
        PrintQueue printQueue;
        public Job(PrintQueue printQueue) {
            this.printQueue = printQueue;
        }
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "开始打印");
            printQueue.printJob(new Object());
            System.out.println(Thread.currentThread().getName() + "打印完毕");
        }
    }
    //打印队列
    class PrintQueue {
        //true：公平
        //false：非公平
        private Lock queueLock = new ReentrantLock(true);
        public void printJob(Object document) {
            queueLock.lock();
            try {
                int duration = new Random().nextInt(10) + 1;
                System.out.println(Thread.currentThread().getName() + "正在打印第一份，需要" + duration + "秒");
                Thread.sleep(duration * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                queueLock.unlock();
            }
            queueLock.lock();
            try {
                int duration = new Random().nextInt(10) + 1;
                System.out.println(Thread.currentThread().getName() + "正在打印第二份，需要" + duration + "秒");
                Thread.sleep(duration * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                queueLock.unlock();
            }
        }
    }

> 特例
> 
>  *  针对tryLock()方法，它是很猛的，它不遵守设定的公平的规则
>  *  例如，当有线程执行tryLock()的时候，一旦有线程释放了锁，那么这个正在tryLock的线程就能获取到锁，即使在它**之前**已经有其他线程在等待队列里面了

> 对比公平和非公平的优缺点

<table>  对比公平和非公平的优缺点  
 <tbody> 
  <tr> 
   <td style="width:75px;">&nbsp;</td> 
   <td style="width:363px;"> <p>优势</p> </td> 
   <td style="width:411px;">劣势</td> 
  </tr> 
  <tr> 
   <td style="width:75px;"> <p>公平锁</p> </td> 
   <td style="width:363px;"> <p>各线程公平平等，每个线程在等待一段时间后，总有执行的机会</p> </td> 
   <td style="width:411px;"> <p>更慢，吞吐量更小</p> </td> 
  </tr> 
  <tr> 
   <td style="width:75px;"> <p>不公平锁</p> </td> 
   <td style="width:363px;"> <p>更快，吞吐量更大</p> </td> 
   <td style="width:411px;"> <p>有可能产生线程饥饿，也就是某些线程在长时间内始终得不到执行</p> </td> 
  </tr> 
 </tbody> 
</table>

> 源码分析
> 
>  *  对比公平锁和非公平锁源码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 12][]

--------------------

# 6 共享锁和排它锁：以ReentrantReadWriteLock读写锁为例（重点） #

> 什么是共享锁和排它锁
> 
>  *  排他锁，又称为独占锁、独享锁
>  *  共享锁，又称为读锁，获得共享锁之后，可以查看但无法修改和删除数据，其他线程此时也可以获取到共享锁，也可以査看但无法修改和删除数据
>  *  共享锁和排它锁的典型是读写锁ReentrantReadWriteLock，其中读锁是共亨锁，写锁是独享锁
> 
> --------------------
> 
> 读写锁的作用
> 
>  *  在没有读写锁之前，我们假设使用ReentrantLock，那么虽然我们保证了线程安全，但是也浪费了一定的资源：多个读操作同时进行，并没有线程安全问题
>  *  在读的地方使用读锁，在写的地方使用写锁，灵活控制，如果没有写锁的情况下，读是无阻塞的，提高了程序的执行效率

> 读写锁的规则
> 
> 1.  多个线程只申请读锁，都可以申请到
> 2.  如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
> 3.  如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
> 4.  一句话总结：要么是一个或多个线程同时有读锁，要么是一个线程有写锁，但是两者不会同时出现（要么多读，要么一写）
> 
> --------------------
> 
>  *  换—种思路更容易理解：读写锁只是一把锁，可以通过两种方式锁定：读锁定和写锁定。读写锁可以同时被一个或多个线程读锁定，也可以被单一线程写锁定。但是永远不能**同时**对这把锁进行读锁定和写锁定。
>  *  这里是把“获取写锁”理解为“把读写锁进行写锁定”，相当于是换了一种思路，不过原则是不变的，就是要么是一个或多个线程同时有读锁（同时读锁定），要么是一个线程有写锁（进行写锁定），但是两者不会同时出现

> ReentrantReadWriteLock具体用法
> 
>  *  电影院升级

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 14][]

public class CinemaReadWrite {
        private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
        private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
        private static void read() {
            readLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "得到了读锁，正在读取");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + "释放读锁");
                readLock.unlock();
            }
        }
        private static void write() {
            writeLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "得到了写锁，正在写入");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + "释放写锁");
                writeLock.unlock();
            }
        }
        public static void main(String[] args) {
            new Thread(() -> read(), "Thread1").start();
            new Thread(() -> read(), "Thread2").start();
            new Thread(() -> write(), "Thread3").start();
            new Thread(() -> write(), "Thread4").start();
        }
    }

/**
     * 悲观读取
     */
    public class LockExample {
        private final Map<String, Data> map = new TreeMap<>();
    
        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        private final Lock readLock = lock.readLock();
        private final Lock writeLock = lock.writeLock();
        public Data get(String key) {
            readLock.lock();
            try {
                return map.get(key);
            } finally {
                readLock.unlock();
            }
        }
        public Set<String> getAllKeys() {
            readLock.lock();
            try {
                return map.keySet();
            } finally {
                readLock.unlock();
            }
        }
        //
        public Data put(String key, Data value) {
            writeLock.lock();//没用读锁才能获取成功
            try {
                return map.put(key, value);
            } finally {
                readLock.unlock();
            }
        }
        class Data {}
    }

> 读锁和写锁的交互方式
> 
>  *  选择规则
>  *  读线程插队（比喻：男女共用厕所，男生可以插队吗？）
>  *  升降级
>  *  公平、非公平

> ReentrantReadWriteLock的实现
> 
>  *  插队：不允许读锁插队
>  *  升降级：允许降级，不允许升级

> 读锁插队策略
> 
>  *  非公平：假设线程2和线程4正在同时读取，线程3想要写入，拿不到锁，于是进入等待队列，线程5不在队列里，现在过来想要读取

>  策略的选择取决于具体锁的实现，ReentrantReadWriteLock的实现是选择了策略2，是很明智的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 15][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 16][]

> 读锁插队策略
> 
> 公平锁：不允许插队
> 
> 非公平锁
> 
>  *  写锁可以随时插队
>  *  读锁仅在等待队列**头结点**不是想获取写锁的线程的时候可以插队

> 源码分析

//java.util.concurrent.locks.ReentrantReadWriteLock.Sync#tryAcquireShared
    protected final int tryAcquireShared(int unused) {
    	Thread current = Thread.currentThread();
    	int c = getState();
    	if (exclusiveCount(c) != 0 &&
    		getExclusiveOwnerThread() != current)
    		return -1;
    	int r = sharedCount(c);
    	//不同类型不同实现
    	if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) {
    		if (r == 0) {
    			firstReader = current;
    			firstReaderHoldCount = 1;
    		} else if (firstReader == current) {
    			firstReaderHoldCount++;
    		} else {
    			HoldCounter rh = cachedHoldCounter;
    			if (rh == null || rh.tid != getThreadId(current))
    				cachedHoldCounter = rh = readHolds.get();
    			else if (rh.count == 0)
    				readHolds.set(rh);
    			rh.count++;
    		}
    		return 1;
    	}
    	return fullTryAcquireShared(current);
    }

//java.util.concurrent.locks.ReentrantReadWriteLock.FairSync
    static final class FairSync extends Sync {
    	private static final long serialVersionUID = -2274990926593161451L;
    	//想获取写锁的线程
    	final boolean writerShouldBlock() {
    		//队列里面是否有排队的 
    		//true：排队 
    		//false：不排队
    		return hasQueuedPredecessors();
    	}
    	//想获取读锁的线程
    	final boolean readerShouldBlock() {
    		//队列里面是否有排队的 
    		return hasQueuedPredecessors();
    	}
    }

//java.util.concurrent.locks.ReentrantReadWriteLock.NonfairSync
    static final class NonfairSync extends Sync {
    	private static final long serialVersionUID = -8159625535654395037L;
    	//想获取写锁，不用判断直接尝试插队
    	final boolean writerShouldBlock() {
    		return false; // writers can always barge(插队)
    	}
    	//想获取读锁
    	final boolean readerShouldBlock() {
    	    //FirstQueuedIsExclusive，队列里面第一个线程是否是想获取写锁
    		return apparentlyFirstQueuedIsExclusive();
    	}
    }

> 代码演示：
> 
> 1.  读不插队
> 2.  读实际上可以插队

public class CinemaReadWrite {
        private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
        private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
        private static void read() {
            readLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "得到了读锁，正在读取");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + "释放读锁");
                readLock.unlock();
            }
        }
        private static void write() {
            writeLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "得到了写锁，正在写入");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + "释放写锁");
                writeLock.unlock();
            }
        }
        public static void main(String[] args) {
            //1读不插队 非公平锁 ReentrantReadWriteLock()
            //Thread5插队失败
            new Thread(() -> write(), "Thread1").start();
            new Thread(() -> read(), "Thread2").start();
            new Thread(() -> read(), "Thread3").start();
            new Thread(() -> write(), "Thread4").start();
            new Thread(() -> read(), "Thread5").start();
            //Thread1得到了写锁，正在写入
            //Thread1释放写锁
            //Thread2得到了读锁，正在读取
            //Thread3得到了读锁，正在读取
            //Thread2释放读锁
            //Thread3释放读锁
            //Thread4得到了写锁，正在写入
            //Thread4释放写锁
            //Thread5得到了读锁，正在读取
            //Thread5释放读锁
        }
    }

public class NonfairBargeDemo {
        private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(false);
        private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
        private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
        private static void read() {
            System.out.println(Thread.currentThread().getName() + "开始尝试获取读锁");
            readLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "得到读锁，正在读取");
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                System.out.println(Thread.currentThread().getName() + "释放读锁");
                readLock.unlock();
            }
        }
        private static void write() {
            System.out.println(Thread.currentThread().getName() + "开始尝试获取写锁");
            writeLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "得到写锁，正在写入");
                try {
                    Thread.sleep(40);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                System.out.println(Thread.currentThread().getName() + "释放写锁");
                writeLock.unlock();
            }
        }
        public static void main(String[] args) {
            new Thread(()->write(),"Thread1").start();
            new Thread(()->read(),"Thread2").start();
            new Thread(()->read(),"Thread3").start();
            new Thread(()->write(),"Thread4").start();
            new Thread(()->read(),"Thread5").start();
            new Thread(() -> {
                Thread thread[] = new Thread[1000];
                for (int i = 0; i < 1000; i++) {
                    thread[i] = new Thread(() -> read(), "子线程创建的Thread" + i);
                }
                for (int i = 0; i < 1000; i++) {
                    thread[i].start();
                }
            }).start();
            //Thread1释放写锁
            //Thread3得到读锁，正在读取
        }

>  锁的升降级
> 
>  *  为什么需要升降级：开始想写，后面想读，拿着写锁有点浪费资源，但是我释放掉了，再次获取锁有点麻烦
>  *  支持锁的降级，不支持升级
>  *  为什么不支持锁的升级？死锁（两个线程都握有同一把读锁，同时想升级为写锁）

/**
     * 演示ReentrantReadWriteLock可以降级，不能升级
     */
    public class Upgrading {
        private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(false);
        private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
        private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
        //读：升级 不可
        private static void readUpgrading() {
            readLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "得到了读锁，正在读取");
                Thread.sleep(1000);
                System.out.println("升级会带来阻塞");
                writeLock.lock();
                System.out.println(Thread.currentThread().getName() + "获取到了写锁，升级成功");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + "释放读锁");
                readLock.unlock();
            }
        }
        //写：降级 可
        private static void writeDowngrading() {
            writeLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "得到了写锁，正在写入");
                Thread.sleep(1000);
                readLock.lock();
                System.out.println("在不释放写锁的情况下，直接获取读锁，成功降级");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                readLock.unlock();
                System.out.println(Thread.currentThread().getName() + "释放写锁");
                writeLock.unlock();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            //------------------先演示降级是可以的------------------//
            //Thread thread1 = new Thread(() -> writeDowngrading(), "Thread1");
            //thread1.start();
            //thread1.join();
            //------------------演示升级是不行的------------------//
            Thread thread2 = new Thread(() -> readUpgrading(), "Thread2");
            thread2.start();
        }
    }

> 实际锁降级的例子
> 
> 在锁降级成功后，也就是持有写锁的时候同时申请并获得了读锁后，此时直接释放写锁，但是不释放读锁，这样就可以提高锁的利用效率，下面这段代码演示了在更新缓存的时候，如何利用锁的降级功能。

public class CachedData {
        Object data;
        volatile boolean cacheValid;
        final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
        void processCachedData() {
            //最开始是读取
            rwl.readLock().lock();
            if (!cacheValid) {
                //发现缓存失效，那么就需要写入了，所以现在需要获取写锁。由于锁不支持升级，所以在获取写锁之前，必须首先释放读锁。
                rwl.readLock().unlock();
                //获取到写锁
                rwl.writeLock().lock();
                try {
                    //这里需要再次判断数据的有效性,因为在我们释放读锁和获取写锁的空隙之内，可能有其他线程修改了数据。
                    if (!cacheValid) {
                        data = new Object();
                        cacheValid = true;
                    }
                    //在不释放写锁的情况下，直接获取读锁，这就是读写锁的降级。
                    rwl.readLock().lock();
                } finally {
                    //释放了写锁，但是依然持有读锁，这样一来，就可以多个线程同时读取了，提高了整体效率。
                    rwl.writeLock().unlock();
                }
            }
            try {
                System.out.println(data);
            } finally {
                //最后释放读锁
                rwl.readLock().unlock();
            }
        }
    }

> 在这段代码中有一个读写锁，最重要的就是中间的 processCachedData 方法，在这个方法中，会首先获取到读锁，也就是 rwl.readLock().lock()，它去判断当前的缓存是否有效，如果有效那么就直接跳过整个 if 语句，如果已经失效，代表我们需要更新这个缓存了。由于我们需要更新缓存，所以之前获取到的读锁是不够用的，我们需要获取写锁。
> 
> 在获取写锁之前，我们首先释放读锁，然后利用 rwl.writeLock().lock() 来获取到写锁，然后是经典的 try finally 语句，在 try 语句中我们首先判断缓存是否有效，因为在刚才释放读锁和获取写锁的过程中，可能有其他线程抢先修改了数据，所以在此我们需要进行二次判断。
> 
> 如果我们发现缓存是无效的，就用 new Object() 这样的方式来示意，获取到了新的数据内容，并把缓存的标记位设置为 ture，让缓存变得有效。由于我们后续希望打印出 data 的值，所以不能在此处释放掉所有的锁。我们的选择是在不释放写锁的情况下直接获取读锁，也就是 rwl.readLock().lock() 这行语句所做的事情，然后，在持有读锁的情况下释放写锁，最后，在最下面的 try 中把 data 的值打印出来。
> 
> 这就是一个非常典型的利用锁的降级功能的代码。
> 
> 你可能会想，我为什么要这么麻烦进行降级呢？我一直持有最高等级的写锁不就可以了吗？这样谁都没办法来影响到我自己的工作，永远是线程安全的。
> 
> 为什么需要锁的降级？
> 
> 如果我们在刚才的方法中，一直使用写锁，最后才释放写锁的话，虽然确实是线程安全的，但是也是没有必要的，因为我们只有一处修改数据的代码：
> 
> data = new Object();
> 
> 后面我们对于 data 仅仅是读取。如果还一直使用写锁的话，就不能让多个线程同时来读取了，持有写锁是浪费资源的，降低了整体的效率，所以这个时候利用锁的降级是很好的办法，可以提高整体性能。

> 共享锁和排它锁总结
> 
>  *  ReentrantReadWriteLock实现了ReadWriteLock接口，最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁
> 
> --------------------
> 
> 锁申请和释放策略
> 
> 1.  多个线程只申请读锁，都可以申请到
> 2.  如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁
> 3.  如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
> 4.  要么是一个或多个线程同时有读锁，要么是一个线程有写锁，但是两者不会同时出现。
> 5.  总结：要么多读，要多一写
> 
> --------------------
> 
>  *  插队策略：为了防止饥饿，读锁不能插队
>  *  升降级策略：只能降级，不能升级
>  *  适用场合：相比于ReentrantLock适用于一般场合，ReentrantReadWriteLock适用于读多写少的情况，合理使用可以进一步提高并发效率。

--------------------

# 7 StampedLock #

> 官方样例

/**
     * StampedLock控制锁有三种模式
     *  1.写
     *  2.读
     *  3.乐观读
     */
    public class LockExample {
        class Point {
            private double x, y;
            private final StampedLock sl = new StampedLock();
            void move(double deltaX, double deltaY) { // an exclusively locked method
                long stamp = sl.writeLock();
                try {
                    x += deltaX;
                    y += deltaY;
                } finally {
                    sl.unlockWrite(stamp);
                }
            }
            //下面看看乐观读锁案例
            double distanceFromOrigin() { // A read-only method
                long stamp = sl.tryOptimisticRead(); //获得一个乐观读锁
                double currentX = x, currentY = y;  //将两个字段读入本地局部变量
                if (!sl.validate(stamp)) { //检查发出乐观读锁后同时是否有其他写锁发生？
                    stamp = sl.readLock();  //如果没有，我们再次获得一个读悲观锁
                    try {
                        currentX = x; // 将两个字段读入本地局部变量
                        currentY = y; // 将两个字段读入本地局部变量
                    } finally {
                        sl.unlockRead(stamp);
                    }
                }
                return Math.sqrt(currentX * currentX + currentY * currentY);
            }
            //下面是悲观读锁案例
            void moveIfAtOrigin(double newX, double newY) { // upgrade
                // Could instead start with optimistic, not read mode
                long stamp = sl.readLock();
                try {
                    while (x == 0.0 && y == 0.0) { //循环，检查当前状态是否符合
                        long ws = sl.tryConvertToWriteLock(stamp); //将读锁转为写锁
                        if (ws != 0L) { //这是确认转为写锁是否成功
                            stamp = ws; //如果成功 替换票据
                            x = newX; //进行状态改变
                            y = newY;  //进行状态改变
                            break;
                        } else { //如果不能成功转换为写锁
                            sl.unlockRead(stamp);  //我们显式释放读锁
                            stamp = sl.writeLock();  //显式直接进行写锁 然后再通过循环再试
                        }
                    }
                } finally {
                    sl.unlock(stamp); //释放读锁或写锁
                }
            }
        }
    }

//线程安全
    @Slf4j
    public class LockExample {
        // 请求总数
        public static int clientTotal = 5000;
        // 同时并发执行的线程数
        public static int threadTotal = 200;
        public static int count = 0;
    
        private final static StampedLock lock = new StampedLock();
        public static void main(String[] args) throws Exception {
            ExecutorService executorService = Executors.newCachedThreadPool();
            final Semaphore semaphore = new Semaphore(threadTotal);
            final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
            for (int i = 0; i < clientTotal ; i++) {
                executorService.execute(() -> {
                    try {
                        semaphore.acquire();
                        add();
                        semaphore.release();
                    } catch (Exception e) {
                        log.error("exception", e);
                    }
                    countDownLatch.countDown();
                });
            }
            countDownLatch.await();
            executorService.shutdown();
            log.info("count:{}", count);
        }
        private static void add() {
            long stamp = lock.writeLock();
            try {
                count++;
            } finally {
                lock.unlock(stamp);
            }
        }
    }

--------------------

# 8 自旋锁和阻塞锁 #

> 概念
> 
>  *  阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态转换需要耗费处理器时间
>  *  如果同步代码块中的内容过于简单，状态转换消耗的时间有可能比用户代码执行的时间还要长
>  *  在许多场景中，同步资源的锁定时间很短，为了这一小段时间去切换线程，线程挂起和恢复现场的花费可能会让系统得不偿失
>  *  如果物理机器有多个处理器，能够让两个或以上的线程同时并行执行，我们就可以让后面那个请求锁的线程不放弃CPU的执行时间，看看持有锁的线程是否很快就会释放锁
>  *  而为了让当前线程“稍等一下”，我们需让当前线程进行自旋，如果在自旋完成后前面锁定同步资源的线程已经释放了锁，那么当前线程就可以不必阻塞而是直接获取同步资源，从而避免切换线程的开销。这就是自旋锁。
>  *  阻塞锁和自旋锁相反，阻塞锁如果遇到没拿到锁的情况，会直接把线程阻塞，直到被唤醒
> 
> --------------------
> 
> 自旋锁的缺点
> 
>  *  如果锁被占用的时间很长，那么自旋的线程只会白浪费处理器资源
>  *  在自旋的过程中，一直消耗cpu，所以虽然自旋锁的起始开销低于悲观锁，但是随着自旋时间的增长，开销也是线性增长的
> 
> --------------------
> 
> 原理和源码分析
> 
>  *  在java1.5版本及以上的并发框架java.util.concurrent的atomic包下的类基本都是自旋锁的实现
>  *  AtomicInteger的实现：自旋锁的实现原理是CAS，AtomicInteger中调用unsafe进行自增操作的源码中的do-while循环就是一个自旋操作，如果修改过程中遇到其他线程竞争导致没修改成功，就在while里死循环，直至修改成功

//java.util.concurrent.atomic.AtomicInteger#getAndIncrement
    public final int getAndIncrement() {
    	return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    //sun.misc.Unsafe#getAndAddInt
    public final int getAndAddInt(Object var1, long var2, int var4) {
    	int var5;
    	do {
    		var5 = this.getIntVolatile(var1, var2);
    	} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    	return var5;
    }

/**
     * 自己写一个简单的实现：自旋锁
     */
    public class SpinLock {
        private final AtomicReference<Thread> sign = new AtomicReference<>();
        //加锁
        public void lock() {
            System.out.println(Thread.currentThread().getName() + " 开始尝试获取自旋锁");
            Thread current = Thread.currentThread();
            while (!sign.compareAndSet(null, current)) {
                // System.out.println(Thread.currentThread().getName() + " 自旋获取失败，再次尝试");
            }
            System.out.println(Thread.currentThread().getName() + " 获取到了自旋锁");
        }
        //解锁
        public void unlock() {
            Thread current = Thread.currentThread();
            System.out.println(Thread.currentThread().getName() + " 释放了自旋锁");
            sign.compareAndSet(current, null);
        }
        public static void main(String[] args) {
            SpinLock spinLock = new SpinLock();
            Runnable runnable = () -> {
                spinLock.lock();
                try {
                    Thread.sleep(300);
                } catch (InterruptedException ignored) {
                } finally {
                    spinLock.unlock();
                }
            };
            Thread thread1 = new Thread(runnable, "AAA");
            Thread thread2 = new Thread(runnable, "BBB");
            thread1.start();
            thread2.start();
        }
    }

> 适用场景
> 
>  *  自旋锁一般用于多核的服务器，在并发度不是特别高的情况下，比阻塞锁的效率高
>  *  另外，自旋锁适用于临界区比较短小的情况，否则如果临界区很大（线程一旦拿到锁，很久以后才会释放），那也是不合适的

--------------------

# 9 可中断锁：顾名思义，就是可以响应中断的锁 #

>  *  在Java中，synchronized就不是可中断锁，而Lock是可中断锁因为tryLock(time)和lockInterruptibly都能响应中断。
>  *  如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以中断它，这种就是可中断锁

--------------------

# 10 选择锁的规则 #

> 1.  当只有少量竞争者的时候，synchronized是一个很好的选择
> 2.  竞争者不少，但是线程增长的趋势我们是可以预估的，ReentrantLock是一个很好的选择

--------------------

# 11 锁优化 #

> Java虚拟机对锁的优化
> 
>  *  自旋锁和自适应
>  *  锁消除
>  *  锁粗化
> 
> --------------------
> 
> 我们在写代码时如何优化锁和提高并发性能
> 
> 1.  缩小同步代码块
> 2.  尽量不要锁住方法
> 3.  减少请求锁的次数
> 4.  避免人为制造“热点”
> 5.  锁中尽量不要再包含锁
> 6.  选择合适的锁类型或合适的工具类

--------------------

# 12 面试题 #

> **synchronized和Lock有什么区别？用新的Lock有什么好处？你举例说说**
> 
> 1、原始构成
> 
> synchronized是关键字属于VM层面，  
>     monitorenter（底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象，只有在同步块或同步方法中才能调wait/notify等方法）  
>     monitorexit
> 
> Lock是具体类(java.util.concurrent.locks.Lock)是api层面的锁
> 
> 2、使用方法
> 
> synchronized不需要用户去手动释放锁，当synchronized代码执行完后系统会自动让线程释放对锁的占用。
> 
> ReentrantLock则需要用户去手动释放锁若没有主动释放锁，就有可能导致出现死锁现象，需要Lock()和lunlock()方法配合try/finally语句块来完成。
> 
> 3、等待是否可中断  
> synchronized不可中断，除非抛出异常或者正常运行完成。
> 
> ReentrantLock可中断，1.设置超时方法tryLock(Long timeout, Timeunit unit)  
>                                       2.lockInterruptibly()放代码块中，调用interrupt()方法可中断
> 
> 4、加锁是否公平
> 
> synchronized非公平锁。
> 
> ReentrantLock两者都可以，默认非公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁。
> 
> 5、锁绑定多个条件Condition
> 
> synchronized没有。
> 
> ReentrantLock用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。

/**
     * 题目: 多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下:
     * AA打印5次，BB打印10次，CC打印15次
     * 紧接着
     * AA打印5次，BB打印10次，CC打印15次
     * ......
     * 来10轮
     */
    class ShareResource {
        private volatile int number = 1; // A:1 B:2 C:3
        private final Lock lock = new ReentrantLock();
        private final Condition c1 = lock.newCondition();
        private final Condition c2 = lock.newCondition();
        private final Condition c3 = lock.newCondition();
        public void print5() {
            lock.lock();
            try {
                // 1.判断
                while (number != 1) {
                    c1.await();
                }
                // 2.干活
                for (int i = 1; i <= 5; i++) {
                    System.out.println(Thread.currentThread().getName() + " number=" + number);
                }
                // 3.通知
                number = 2;
                c2.signal(); // 精确唤醒
            } catch (Exception ignore) {
            } finally {
                lock.unlock();
            }
        }
        public void print10() {
            lock.lock();
            try {
                // 1.判断
                while (number != 2) {
                    c2.await();
                }
                // 2.干活
                for (int i = 1; i <= 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " number=" + number);
                }
                // 3.通知
                number = 3;
                c3.signal(); // 精确唤醒
            } catch (Exception ignore) {
            } finally {
                lock.unlock();
            }
        }
        public void print15() {
            lock.lock();
            try {
                // 1.判断
                while (number != 3) {
                    c3.await();
                }
                // 2.干活
                for (int i = 1; i <= 15; i++) {
                    System.out.println(Thread.currentThread().getName() + " number=" + number);
                }
                // 3.通知
                number = 1;
                c1.signal(); // 精确唤醒
            } catch (Exception ignore) {
    
            } finally {
                lock.unlock();
            }
        }
    }
    public class Main {
        public static void main(String[] args) {
            ShareResource shareResource = new ShareResource();
            new Thread(() -> {
                for (int i = 1; i <= 10; i++) {
                    shareResource.print5();
                }
            }, "A").start();
            new Thread(() -> {
                for (int i = 1; i <= 10; i++) {
                    shareResource.print10();
                }
            }, "B").start();
            new Thread(() -> {
                for (int i = 1; i <= 10; i++) {
                    shareResource.print15();
                }
            }, "C").start();
        }
    }

[https_blog.csdn.net_qq_40794973_article_details_103960056_t9]: https://blog.csdn.net/qq_40794973/article/details/103960056#t9
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200125163325742.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020012516354080.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200125170606810.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200125174717552.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200125174921627.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200125180018952.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[https_yuanyu.blog.csdn.net_article_details_104111726_t11]: https://yuanyu.blog.csdn.net/article/details/104111726#t11
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200125195338380.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200125195237119.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200125195140483.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_qq_40794973_article_details_103880263_t8]: https://blog.csdn.net/qq_40794973/article/details/103880263#t8
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200125203158392.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200125214322458.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200125214856223.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200125221243301.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200125223748838.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/2020012522390770.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/2020012523021449.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200125230648893.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70