java当中的各种锁（公平锁、非公平锁、可重入锁、自旋锁、读写锁）

一、公平锁和非公平锁

公平锁：就是很公平，在并发情况下，每个线程在获取锁时会查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己。（按先后顺序执行）

非公平锁：非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采取类似公平锁那种方式。

例如：

new ReentrantLock();

默认是非公平锁，如果在参数列表加入true则为公平锁，加入false则为非公平锁。

特点：非公平锁执行效率快，吞吐量会更大，但是会造成优先级反转和饥饿现象

饥饿现象：一个线程长时间没有获取到执行权。

二、可重入锁（递归锁）

可重入锁（递归锁）：指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

就是说，拿到一把锁，只要其他代码是被这把锁锁住的，那么都能随意访问。如：synchronized和ReentrantLock都是同步锁。

上代码（这里只演示ReentrantLock锁，synchronized与之类似不再赘述）

class Phone implements Runnable {

  

    Lock lock = new ReentrantLock();


    @Override
    public void run() {
        get();
    }

    public void get() {
        //可以同时加多把锁，但是加锁次数和解锁次数相同才可以，否则锁得不到释放会导致死锁
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t invoked get()");
            set();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

    public void set() {
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName() + "\t invoked set()");
        } finally {
            lock.unlock();
        }
    }
}


public class ReenterLockDemo {

    public static void main(String[] args) {
        Phone phone = new Phone();
        

        Thread t3 = new Thread(phone, "t3");
        t3.start();

    }
}

控制台打印：

 

所以我们能够看到，只要当前线程有了这把锁，那么只要被这把锁锁住的代码块都能被访问到。（注：ReentrantLock中的lock和unlock要配对，否则会造成死锁问题）

三、自旋锁

自旋锁：是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下切换的消耗，缺点是循环会消耗CPU。

手写一个自旋锁：

上代码：

public class SpinLockDemo {

    //原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in");

        while (!atomicReference.compareAndSet(null,thread)){

        }
    }

    public void myUnlock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(thread.currentThread().getName() + "\t invoked myUnlock()");
    }


    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(()->{
            try {
                spinLockDemo.myLock();
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        },"AA").start();

        //保证A线程先进入
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            spinLockDemo.myLock();
            spinLockDemo.myUnlock();
        },"BB").start();
    }
}

 这段代码我们写的是两个线程，用compareAndSet方法设置，如果原子引用对象atomicReference中的值为null，那么就将该线程赋值给atomicReference对象，如果不为null那么就执行循环操作

注意：自旋锁会使其他线程一直处于自旋状态，CPU会飙高，所以看实际需求进行使用。

四、读写锁

其实这里有两个锁：一个是读锁，一个是写锁，读锁是一个共享锁，而写锁是一个独占锁，那么我们先来看下共享锁和独占锁的概念

共享锁：指该锁可被多个线程所持有。

独占锁：指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁。

就是要求，读是大家都可以访问的，但是写，只能有一个线程执行，读写锁还要求：读-读可以共存，读-写不能共存，写-写不能共存，为什么呢？读和读的时候访问的资源不会被改变，而读的时候进行写操作，或者写的时候进行写操作都会导致出现数据不一致的问题。

那么我们来看一下读写锁的实现代码：

public class ReadWriteLockDemo {

    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for (int i = 0; i < 5; i++) {
            int tempInt = i;
            new Thread(()->{
                myCache.put(tempInt + "", tempInt);
            },String.valueOf(i)).start();
        }
        for (int i = 0; i < 5; i++) {
            int tempInt = i;
            new Thread(()->{
                myCache.get(tempInt + "");
            },String.valueOf(i)).start();
        }

    }
}



//资源类
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void put(String key,Object value){
        rwLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + "\t正在写入" + key);

        try {
            //模拟网络拥堵
            TimeUnit.MILLISECONDS.sleep(300);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "\t写入完成" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rwLock.writeLock().unlock();
        }
    }


    public void get(String key){
        rwLock.readLock().lock();
        System.out.println(Thread.currentThread().getName() + "\t正在读取");
        try {
            //模拟网络拥堵
            TimeUnit.MILLISECONDS.sleep(300);
            Object res = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t读取完成" + res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rwLock.readLock().unlock();
        }
    }
}

 

控制台打印：

这段代码中我使用了JUC包中的ReentrantReadWriteLock来演示读写锁的情况，我们可以看到

写操作是原子的，不能被打断，但是读操作是可以被共享的。