java的公平锁，非公平锁，可重入锁（递归锁），自旋锁，读写锁

例子：ReentrantLock（默认是非公平锁，当设置为ture是，就是公平锁）
1、公平锁（多线程按照申请锁来获取锁）
2、非公平锁（指多线程获取锁的顺序不是按申请顺序，在高并发情况下，有可能出现优先级反转，先尝试申请锁，如果不成功在排队申请锁）
3、可重入锁（指线程可以进入任何一个已经拥有锁的同步代码块）最大作用是避免死锁。（ReentrantLock和synchronized都是可重入锁）
4、自旋锁（尝试获取锁的线程不会立刻阻塞，才要循环的方式进行尝试取锁）减少线程上下文的切换消耗，缺点是消耗CPU
5、读锁（共享锁：读读），写锁（独占锁：读写，写读，写写），互斥锁
例子使用

class myCahw{
    private volatile Map<String,Object> m = new HashMap<>();
    private ReentrantReadWriteLock r = new ReentrantReadWriteLock();

    public void send(String key,Object value){
        r.writeLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + key + "正在写入");
                TimeUnit.SECONDS.sleep(1);
                m.put(key,value);
                System.out.println("写入完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                r.writeLock().unlock();
            }
    }

    public void find(String key){

        r.readLock().lock();
        try {
            System.out.println("正在读入");
            TimeUnit.SECONDS.sleep(5);
            Object o = m.get(key);
            System.out.println("读入完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            r.readLock().unlock();
        }
    }
}


public class Test {
    public static void main(String[] args) {
        myCahw test = new myCahw();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                final int tempInt = 1;
                test.send(tempInt + "",tempInt + "");
            },"AA").start();
        }
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                final int tempInt = 1;
                test.find(tempInt + "");
            },"BB").start();
        }
    }
}