Java锁：可重入锁实现公平，非公平锁Java锁：可重入锁实现公平，非公平锁

什么是可重入锁

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

可重入锁代码测试：

package InterviewTest;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Phone implements Runnable{
/*****************************synchronized*****************************/
	public synchronized void sendSMS() throws Exception{
		System.out.println(Thread.currentThread().getName()+"   invoked sendSMS");
		sendEmail();
	}
	
	public synchronized void sendEmail() throws Exception{
		System.out.println(Thread.currentThread().getName()+"**********   invoked sendEmail");
	}
/********************ReentrantLock************************************/
	Lock Lock = new ReentrantLock();
	@Override
	public void run() {
		get();
		
	}

	public void get() {
		Lock.lock();
//		Lock.lock();
		try {
			System.out.println(Thread.currentThread().getName()+"   invoked get");
			set();
		} finally {
			Lock.unlock();
//			Lock.unlock();
			/*
			 * 只要lock和unlock方法的数目匹配那么就能成功运行
			 * 但是如果不匹配的话程序就会卡死，无法正确退出
			 */
		}
	}
	
	public void set() {
		Lock.lock();
		try {
			System.out.println(Thread.currentThread().getName()+"   invoked set");
		} finally {
			Lock.unlock();
		}
	}
	
}
/*
 * 可重入锁，也叫递归锁，

 * 
 * 指的是在同一线程的外层函数获得锁之后，内层函数仍然能和获取该锁的代码。
 * 在同一个线程在外层方法获取锁的时候，在进入内层方法的时候会自动获取锁
 * 
 * 也就是说，线程可以进入任何一个它已经拥有的锁所锁着的代码块
 * 
 * 举例：在进入自己家大门的时候需要锁，进入大门之后，
 * 再进入其他房间就不需要再开锁了，
 * 
 * t1   invoked sendSMS                   t1线程在外层方法获取锁的时候
 * t1**********   invoked sendEmail       t1在进入内层方法会自动获取锁
 * 
 * 
 * t2   invoked sendSMS                   t2线程在外层方法获取锁的时候
 * t2**********   invoked sendEmail       t2在进入内层方法会自动获取锁
 */

public class ReentrantLockDemo {
	public static void main(String[] args) {
		Phone phone = new Phone();
		
/*****************************synchronized*****************************/		
		new Thread(() -> {
			try {
				phone.sendSMS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"t1").start(); 
		
		new Thread(() -> {
			try {
				phone.sendSMS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"t2").start(); 
		
		
		System.out.println();
		System.out.println();
		System.out.println();
		System.out.println();
		
//		try {
//			Thread.sleep(1000);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
/********************ReentrantLock************************************/		
		Thread t3 = new Thread(phone,"t3");
		Thread t4 = new Thread(phone,"t4");
		
		t3.start();
		t4.start();
	}

}

公平锁和非公平锁

公平锁是指多 个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到。
非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁
在高并发的情况下，有可能会造成优先级反转或者饥饿现象

公平锁/非公平锁：
并发包中ReentrantLocK的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是非公平锁
关于两者区别:
公平锁: Threads acquire a fair lock in the order in which they requested it
公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队 列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己
非公平锁: a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock
happens to be available when it is requested.
非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。