上一篇文章，我们熟悉了Java锁的分类。今天，来学习下Java中常用的悲观锁synchronized和ReetrantLock吧。学习使我快乐，哦耶！
synchronized
synchronized是什么？
synchronized关键字可以保证，一段时间内共享资源只能被一个线程所使用，或者说一段代码一段时间内只能被一个线程执行，并且共享资源对其他线程是可见的。
实际上，synchronized就是，某个线程拿到一个锁，锁住共享资源，当使用完，放开锁，让其他线程申请锁并使用共享资源。
synchronized锁的级别
synchronized作用在普通方法或者代码片段上时，锁为对象本身。作用在static方法或者代码片段上时，锁为类本身。
synchronized的基本使用
我们设想一个卖票场景，有A、B两个售票窗口卖票，票池(共享资源)只有一个。
实验1
public class SellTicketRunnable implements Runnable {
// 剩余票数
static int ticket = 1000;
@Override
public void run() {
for (int i=0;i<550;i++){
sell();
}
}
// 买票操作
private synchronized void sell() {
System.out.println(Thread.currentThread().getName()+"开始卖票");
try {
// 模拟卖票
if (ticket <= 0){
System.out.println(Thread.currentThread().getName()+"窗口通知，票卖完了~");
}else {
Thread.sleep(5);
ticket--;
System.out.println(Thread.currentThread().getName()+"出票成功，现在还有"+ticket+"张票");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"结束卖票");
}
}
public static void main(String[] args) throws InterruptedException {
// 代码示例 1 基本使用
SellTicketRunnable sellTicketRunnable = new SellTicketRunnable();
Thread thread_1 = new Thread(sellTicketRunnable,"A窗口");
Thread thread_2 = new Thread(sellTicketRunnable,"B窗口");
thread_1.start();
thread_2.start();
thread_1.join();
thread_2.join();
System.out.println("运行结束，剩下"+SellTicketRunnable.ticket+"张票");
}
首先创建售票类SellTicketRunnable，定义公告资源ticket为1000张票，我们每个窗口模拟卖票550张，如果发现票卖完了，就系统提示，否则票数减1。main方法开启两个线程，发现完美运行。发现票数最终为0，并且每个线程访问共享资源的时间内都是独享的。
A窗口开始卖票
A窗口窗口通知，票卖完了~
A窗口结束卖票
B窗口开始卖票
B窗口窗口通知，票卖完了~
B窗口结束卖票
运行结束，剩下0张票
synchronized对象级别的锁
刚才只生成了一个SellTicketRunnable，只有一把锁。那我们生成两个SellTicketRunnable对象，会不会有两把锁呢？
实验2
SellTicketRunnable sellTicketRunnable = new SellTicketRunnable();
SellTicketRunnable sellTicketRunnable_backups = new SellTicketRunnable();
Thread thread_1 = new Thread(sellTicketRunnable,"A窗口");
Thread thread_2 = new Thread(sellTicketRunnable_backups,"B窗口");
thread_1.start();
thread_2.start();
thread_1.join();
thread_2.join();
System.out.println("运行结束，剩下"+SellTicketRunnable.ticket+"张票");
// 运行结果如下：
A窗口开始卖票
B窗口开始卖票
A窗口出票成功，现在还有999张票
A窗口结束卖票
A窗口开始卖票
B窗口出票成功，现在还有998张票
B窗口结束卖票
B窗口开始卖票
A窗口出票成功，现在还有997张票
A窗口结束卖票
...
运行结束，剩下-1张票
将main方法改成上边所示。首先，访问共享资源的时间不再独享。A窗口还没访问完数据库呢，B窗口就去访问了。这最终导致票可能超卖。(就剩1张票了，A、B窗口同时卖出，同时更新共享资源)。当然这段代码你多运行几次才会出现剩余-1的情况，有时候可能为0，毕竟那么巧的事，不是每次都遇到哈。说明，此时锁是对象级别的。
实际上，如果synchronized作用在对象级别上。内存中，对象的对象头会记录当前获取锁的线程，利用的是Monitor机制。
synchronized类级别的锁
实验3
public class SellTicketRunnablePlus implements Runnable {
// 剩余票数
static int ticket = 1000;
@Override
public void run() {
for (int i=0;i<550;i++){
sell();
}
}
public void sell() {
synchronized(SellTicketRunnablePlus.class){
System.out.println(Thread.currentThread().getName()+"开始卖票");
try {
// 模拟卖票
if (ticket <= 0){
System.out.println(Thread.currentThread().getName()+"窗口通知，票卖完了~");
}else {
Thread.sleep(5);
ticket--;
System.out.println(Thread.currentThread().getName()+"出票成功，现在还有"+ticket+"张票");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"结束卖票");
}
}
}
// 运行结果
A窗口开始卖票
A窗口窗口通知，票卖完了~
A窗口结束卖票
B窗口开始卖票
B窗口窗口通知，票卖完了~
B窗口结束卖票
运行结束，剩下0张票
将实验2主函数中的SellTicketRunnable类换成SellTicketRunnablePlus。SellTicketRunnablePlus只是给sell方法内部，synchronized锁的是SellTicketRunnablePlus类。此时又是一把锁了，所以两个窗口又可以某段时间内独享共享资源了。
synchronized是重入锁
synchronized可以保证不同线程同一时间只能有有一个独享共享资源，比如说线程1持有了锁，线程2去申请锁的时候，发现线程1持有锁呢，所以线程2需要等会(线程阻塞)。那么线程1在持有锁的情况下，可以再申请一把同样的锁吗？
实验4
public class ReentryTest {
public synchronized void outMethod(){
innerMethod();
System.out.println("这是外部方法，执行了");
}
private synchronized void innerMethod(){
System.out.println("这是内部方法，执行了");
}
}
// main方法
ReentryTest reentryTest = new ReentryTest();
reentryTest.outMethod();
//运行结果
这是内部方法，执行了
这是外部方法，执行了
当线程1执行outMethod方法时，获得了锁。outMethod调用innerMethod方法时，线程1又去申请了同一把锁，发现申请成功了。可重入锁是指同一个线程可以多次加同一把锁。
自JDK1.6开始，当只有两个线程竞争锁时，synchronized是轻量级锁，超过两个线程竞争的时候是重量级锁。关于锁的分类，请戳链接: Java锁分类原来是这个样子。
ReetrantLock
synchronized是关键字，很多操作都是隐式的，比如说释放锁、自旋次数等，都是虚拟机帮你搞定的。为了显示操作，并且拥有更强大的功能，ReetrantLock来了。
ReetrantLock基本使用
实验5
ReentrantLock lock = new ReentrantLock();
lock.lock();
try{
// 业务逻辑
}catch (Exception e){
}finally {
lock.unlock();
}
ReetrantLock需要手动申请锁和释放锁，分别为方法lock和unlock。
ReetrantLock重入性
和synchronized一样，ReetrantLock也具备重入性。
实验6
ReentrantLock lock = new ReentrantLock();
int count = 0;
for (int i = 1; i <= 3; i++) {
lock.lock();
System.out.println("说明获取锁"+ ++count +"次");
}
for (int i = 1; i <= 3; i++) {
lock.unlock();
}
//
说明获取锁1次
说明获取锁2次
说明获取锁3次
公平锁和非公平锁
ReetrantLock可以申请公平锁或者非公平锁(了解锁的分类:Java锁分类原来是这个样子)。
首先我们补充一个知识点，ReetrantLock是实现AQS机制的，就是说所有申请锁的线程，会被按需放到一个队列中，然后依次获取锁。公平锁保证了，获取锁的顺序性。
实验7
//主函数
ReentrantLock lock = new ReentrantLock(true);
for (int i=1;i<=5;i++){
new Thread(new FairLockThread(lock),"第"+i+"个").start();
}
// FairLockThread类
public class FairLockThread implements Runnable {
ReentrantLock lock;
public FairLockThread(ReentrantLock lock) {
this.lock = lock;
}
@Override
public void run() {
for (int i = 1; i <= 2; i++) {
lock.lock();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "开始执行了");
System.out.println(Thread.currentThread().getName() + ":" + lock.getQueueLength());
lock.unlock();
}
}
}
// 结果
第1个开始执行了
第1个:4
第2个开始执行了
第2个:4
第3个开始执行了
第3个:4
第4个开始执行了
第4个:4
第5个开始执行了
第5个:4
第1个开始执行了
第1个:4
第2个开始执行了
第2个:3
第3个开始执行了
第3个:2
第4个开始执行了
第4个:1
第5个开始执行了
第5个:0
ReentrantLocknew的时候传入true，就是申请了一把公平锁。FairLockThread方法里面让一个线程执行两次申请锁、释放锁操作，并且模拟使用锁0.5秒。getQueueLength方法就是查看，当前队列中阻塞的线程数。可以看出，锁的两遍申请是按照顺序的，从1~5。从线程是也可以看出，没有哪个线程可以偷偷的自己两边都执行完。
还是实验7
ReentrantLock lock = new ReentrantLock(false);
// 结果
第2个开始执行了
第2个:4
第2个开始执行了
第2个:4
第1个开始执行了
第1个:3
第1个开始执行了
第1个:3
第3个开始执行了
第3个:2
第4个开始执行了
第4个:2
第4个开始执行了
第4个:2
第5个开始执行了
第5个:1
第5个开始执行了
第5个:1
第3个开始执行了
第3个:0
我们只需要将主函数，newReentrantLock的时候设置成false，此时申请的就是非公平锁了。再看运行结果，某个线程执行完第一遍，很大概率上就会执行第二遍。没有按照顺序执行，这是不公平的。
执行完一遍，然后紧接着执行第二遍，不用切换上下文，某线程一致使用CPU，这样效率更快的，所以非公平锁效率更高。
ReetrantLock可中断，预防死锁问题
试想一下，如果线程1已经持有锁1，现在想拿锁2，然后就可以开心的结束了。线程2已经持有锁2，现在想拿锁1，然后就可以开心的结束了。这俩线程还愉快的碰面了，结果谁都不放手，谁都不能愉快的结束，于是乎，死锁就产生了。
实验8
public class InterruptThread implements Runnable{
ReentrantLock firstLock;
ReentrantLock secondLock;
public InterruptThread(ReentrantLock firstLock, ReentrantLock secondLock) {
this.firstLock = firstLock;
this.secondLock = secondLock;
}
@Override
public void run() {
try {
firstLock.lock();
Thread.sleep(1000);
secondLock.lock();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
firstLock.unlock();
secondLock.unlock();
System.out.println(Thread.currentThread().getName()+"正常结束!");
}
}
}
// 主函数
ReentrantLock lock = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();
Thread a = new Thread(new InterruptThread(lock, lock2), "A");
Thread b = new Thread(new InterruptThread(lock2, lock), "B");
a.start();
b.start();
//结果
没有结果...
以上，运行到电脑死机也不会结束了。如果我们在主函数最后一行后面加上一行
a.interrupt();
运行结果，放个图吧。
可以看出，虽然A牺牲掉了，但是由于A的中断(放弃持有锁1)。B顺利完成了！为小A默哀一分钟。。。
相同与不同
相同
synchronized和ReetrantLock都是悲观锁、可重入锁。
不同
synchronized是隐士申请、释放锁，虚拟机层面维护。ReetrantLock是显示操作，代码维护。- 在JDK1.6之前，
synchronized性能极差，1.6之后，它俩性能差不多。 ReetrantLock可中断，避免死锁产生。ReetrantLock可以申请公平锁或者非公平锁，可根据需求定制。
呜呼，从探索到验证，辣条君用了一天，小伙伴们点个赞再走吧。