多线程：锁

公平和非公平锁

公平锁：是指多个线程按照申请锁的顺序来获取锁，类似于排队，先来后到，先进先出（FIFO）

非公平锁：是指多个线程并不按照申请锁的顺序来获取锁，允许加塞。再高并发情况下，有可能载成优先级反转或者饥饿现象。

juc并发包中的ReentrantLock，可以通过构造函数 的boolean类型来得到公平锁或非公平锁，默认是非公平锁。非公平锁的有点在于吞吐量大于公平锁。

对于synchronized而言，也是一种非公平锁。

可重入锁

又名递归锁

指的是同一线程外层函数获得锁之后，进入内层函数会自动获取锁。即：线程可以进入任何一个它已经拥有的锁所同步着的代码块。

ReentrantLock/synchronized就是典型的可重入锁。

可重入锁最大作用就是避免死锁。

自旋锁

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

实现一个简单的自旋锁：

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

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            lock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            unLock();
        },"t1").start();

        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            lock();
            unLock();
        },"t2").start();
    }

    public static void lock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+":come in");
        while(!atomicReference.compareAndSet(null, thread)){
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("自旋中");
        }
    }

    public static void unLock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+":unlock");
        atomicReference.compareAndSet(thread, null);
    }

独占锁(写锁)/共享锁(读锁)/互斥锁

独占锁：只该锁一次只能被一个线程所持有，对ReentrantLock/synchronized而言都是独占锁。

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

对ReentrantReadWriteLock，其读锁是共享锁，其写锁是独占锁

读锁的共享锁可保证并发读是非常高效的，写读、读写、写写的过程是互斥的

没有加读写锁：

//资源类
class MyCache{

    private volatile Map<String, Object> map = new HashMap<>();

    public void put(String key, Object value){
        System.out.println(Thread.currentThread().getName()+"线程正在写入"+key);
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"线程写入完成");
    }

    public Object get(String key){
        System.out.println(Thread.currentThread().getName()+"线程正在读取"+key);
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"线程读取完成:" + o);
        return o;
    }
}

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

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

        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                myCache.get(tempInt + "");
            },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();
        try {
            System.out.println(Thread.currentThread().getName()+"线程正在写入"+key);
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"线程写入完成");
        }finally {
            rwLock.writeLock().unlock();
        }

    }

    public Object get(String key){
        rwLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"线程正在读取"+key);
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"线程读取完成:" + o);
            return o;
        }finally {
            rwLock.readLock().unlock();
        }
    }
}