JUC高并发编程(四)——公平锁、非公平锁、可重入锁、死锁

 synchonized关键字实现同步的基础，java中的每一个对象都可以作为锁。

具体表现为以下三种方式：

对于普通同步方法：锁是当前实例对象。

对于静态同步方法：锁是当前类的Class对象。

对于同步方法块：锁是synchonized括号里面配置的对象。

公平锁和非公平锁：
//定义重入锁lock
private final Lock lock = new ReentrantLock(true);参数为true就是公平锁，为false为非公平锁。

1、公平锁

定义：多个线程按照先到先得的策略获取锁。

优点：所有线程都有机会获得锁，不会饿死

缺点：由于所有线程都会经历阻塞态，因此唤醒阻塞线程的开销会很大。

2、非公平锁

定义：所有的线程拼运气，谁运气好，谁就获取到锁

优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高

缺点：可能会有线程长时间甚至永远获取不到锁，导致饿死。
作者：水千里
链接：https://www.jianshu.com/p/9a38f82f646b
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3、重入锁

synchonized（隐式）和lock(显式)都式可重入锁；

 解释一：可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。

 解释二：可重入锁又称递归锁，是指同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁(前提是锁对象得是同一个对象)，不会因为之前已经获取过锁还没有释放而阻塞。

4、死锁

package com.example.deadlock;

import java.util.concurrent.TimeUnit;

/**
 * 死锁演示
 */
public class DeadLockDemo {

    static Object a=new Object();
    static Object b=new Object();

    public static void main(String[] args) {
        new Thread(()->{
            synchronized(a) {
                System.out.println(Thread.currentThread().getName()+"线程获取到锁a，试图获取锁b");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b){
                    System.out.println(Thread.currentThread().getName()+"线程获取锁b");
                }
            }
        },"AA").start();

        new Thread(()->{
            synchronized(b) {
                System.out.println(Thread.currentThread().getName()+"线程获取到锁b，试图获取锁a");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (a){
                    System.out.println(Thread.currentThread().getName()+"线程获取锁a");
                }
            }
        },"BB").start();
                
    }
}

由上图可知：线程AA和线程BB都处于等待过程，线程死锁。