什么是公平锁，非公平锁，递归锁，独占锁（写锁），共享锁（读锁），自旋锁？

递归锁，独占锁（写锁），共享锁（读锁），自旋锁？"/>

什么是公平锁，非公平锁，递归锁，独占锁（写锁），共享锁（读锁），自旋锁？

1.公平锁，非公平锁

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


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

// 非公平锁
Lock lock = new ReentrantLock(); // 公平锁
Lock lock = new ReentrantLock(true);

Java ReentrantLock 而言，通过构造器函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

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

2.递归锁（可重入锁）

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

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

3.自旋锁（spinlock）

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

自定义字段锁，代码如下：

public class SpinlockDemo {private AtomicReference<Thread> atomicReference = new AtomicReference<Thread>(); public void lock() {Thread thread = Thread.currentThread();do {} while (!atomicReferencepareAndSet(null, thread));}public void unlock() {atomicReference.set(null);}public static void main(String[] args) throws InterruptedException {SpinlockDemo spinlockDemo = new SpinlockDemo();new Thread(() -> {System.out.println("t1--->获取锁");spinlockDemo.lock();System.out.println("t1--->获取锁成功");try {System.out.println("t1--->");Thread.sleep(5 * 1000);} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println("t1--->解锁");spinlockDemo.unlock();System.out.println("t1--->解锁成功");}}, "t1").start();Thread.sleep(1000);new Thread(() -> {System.out.println("t2--->获取锁");spinlockDemo.lock();System.out.println("t2--->获取锁成功");try {System.out.println("t2--->");Thread.sleep(1 * 1000);} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println("t2--->解锁");spinlockDemo.unlock();System.out.println("t2--->解锁成功");}}, "t2").start();}
}

4. 读写锁

多个线程同事读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同是进行。但是，如果有一个线程想去写共享资源，就不应该再有其他的线程可以对该资源进行读或者写。


读-读共存
读-写互斥
写-写互斥

class MyCache {private volatile Map<String, Object> map = new HashMap<>();private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();public void put(String key, Object value) {lock.writeLock().lock();try {System.out.println(Thread.currentThread().getName() + "\t正在写入：" + key);Thread.sleep(300);map.put(key, value);System.out.println(Thread.currentThread().getName() + "\t写入完成");} catch (InterruptedException e) {e.printStackTrace();} finally {lock.writeLock().unlock();}}public void get(String key) {lock.readLock().lock();try {System.out.println(Thread.currentThread().getName() + "\t正在读取：" + key);Thread.sleep(300);Object value = map.get(key);System.out.println(Thread.currentThread().getName() + "\t读取完成：" + value);} catch (InterruptedException e) {e.printStackTrace();} finally {lock.readLock().unlock();}}}public class ReadWriteLockDemo {public static void main(String[] args) {MyCache cache = new MyCache();for (int i = 0; i < 5; i++) {final String temp = String.valueOf(i);new Thread(() -> {cache.put(temp, temp);}, String.valueOf(i)).start(); }for (int i = 0; i < 5; i++) {final String temp = String.valueOf(i);new Thread(() -> {cache.get(temp);}, String.valueOf(i)).start(); }}
}

上面的结果没有按照顺序打印出来，可以看出，在读的过程中是异步的！！