【锁《一》】全面认识锁，公平锁/非公平锁/可重入锁/递归锁/自旋锁

【问题1】公平锁非公平锁是什么，区别？

公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到。队列，先到先得

非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。在高并发的情况下，有可能会造成优先级反转或者饥饿现象。

ReentranLock默认是非公平锁，synchronized也是非公平锁

并发包中的ReentranLock的创建可以指定构造函数的Boolean类型来得到公平锁或非公平锁，默认是非公平锁两者区别：公平锁就是很公平，在并发的情况下，每个线程在获取锁时会查看此锁维护的等待队列，如果为空，或者当前线程时等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己。FIFO:先进先出

非公平锁：非公平锁比较粗鲁，上来就直接尝试锁，如果尝试失败，就在采取类似公平锁那种方式。非公平锁的优点在于吞吐量比公平锁大。

总结：公平锁：先来后到    非公平锁：先抢先得

【问题2】可重入锁（也就是递归锁）

指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，再进入内层方法会自动获取锁。也就是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。

ReentranLock/Synchronized就是一个典型的可重入锁。可重入锁的最大的作用就是避免死锁。

跑一个demo验证一下

package com.neu.controller.study;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//代码  操作   资源类
class Phone implements Runnable{
    public synchronized void sendSMS(){//sendEmial在sendSMS的里面，调用
        System.out.println(Thread.currentThread().getName()+"\t sendSMS()");
        sendEmial();
    }
    public synchronized void sendEmial(){
        System.out.println(Thread.currentThread().getName()+"\t ######## sendEmail()");
    }

    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        get();
    }
    public void get() {
        //lock.lock(); //若是开启两个锁，没有配对的关闭，则会造成阻塞。所以lock和unlock是成对成对的存在的
        lock.lock();
        try{
            System.out.println(Thread.currentThread().getName()+"\t get()");
            set();
        }finally {
            //lock.unlock();
            lock.unlock();
        }
    }
    public void set() {
        lock.lock();
        try{
            System.out.println(Thread.currentThread().getName()+"\t set()");
        }finally {
            lock.unlock();
        }

    }
}

/**
 * 可重入锁（也就是递归锁）：指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，
 * 在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
 *
 * 也就是说，线程可以进入任何一个它已经拥有的锁所有同步着的代码块。
 *  证明synchronized是一个典型的可重入锁
 * t1	 sendSMS()
 * t1	 ######## sendEmail()
 * t2	 sendSMS()
 * t2	 ######## sendEmail()
 *
 * case two ReentrantLock是一个典型的可重入锁
 */
public class ReenterLockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSMS();
        },"t1").start();
        new Thread(()->{
            phone.sendSMS();
        },"t2").start();


        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("=====================================");
        Thread t3 = new Thread(phone,"t3");
        Thread t4 = new Thread(phone,"t4");
        t3.start();
        t4.start();
    }
}

运行结果

t1     sendSMS()
t1     ######## sendEmail()
t2     sendSMS()
t2     ######## sendEmail()
=====================================
t3     get()
t3     set()
t4     get()
t4     set()

【问题3】自旋锁，手写一个自旋锁

是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式来尝试获取锁，这样的好处是减少线程上下文的消耗，缺点是循环会消耗CPU。循环代替阻塞

就是CAS的实现原理

package com.neu.controller.study;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinLockDemo {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();//默认的主内存种的线程是null

    public void lock(){
        Thread thread = Thread.currentThread();
        System.out.println("当前线程"+thread.getName());
        while(!atomicReference.compareAndSet(null,thread)){
            //System.out.println("期望值与主内存值不同，我自旋等待");//若是想更清楚的看线程B等待的过程，可以输出这段话更直观
        }
    }
    public void unLock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(thread.getName()+"解锁");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(()->{
            spinLockDemo.lock();//A加锁
            try{ TimeUnit.SECONDS.sleep(2);}catch(Exception e){e.printStackTrace();}
            spinLockDemo.unLock();
        },"A").start();

        new Thread(()->{
            spinLockDemo.lock();
            try{ TimeUnit.SECONDS.sleep(1);}catch(Exception e){e.printStackTrace();}
            spinLockDemo.unLock();
        },"B").start();
    }
}

运行结果：

当前线程A
当前线程B
A解锁
B解锁