并发包下的重入锁(ReentrantLock)

重入锁可以完全替代synchronized关键字。在JDK5.0的早期版本中，重入锁的性能完全好于synchronized。但是JDK6.0对synchronized做了大量的优化，使得两者差距并不大了，但是 ReentrantLock 灵活性要远高于synchronized。

1.为什么叫重入锁？

答：从名称上看，翻译挺贴切的, re-entrant-lock 重-入-锁。之所以这么叫是因为这种锁是可以反复进入的。当然，仅仅局限于一个线程是可以反复的。

lock.lock();

lock.lock();

try {

i++;

}catch (Exception e) {

lock.unlock();

lock.unlock();

}

一个线程可以连续两次获得同一把锁。释放锁也要多释放一次。

2.中断响应

对于synchronized来说，如果一个线程在等待锁，那么只有与两种结果，第一，得到锁，第二 继续等待。而使用重入锁，则提供另外一种可能，那就是线程可以被中断。也就是程序可以选择性的取消对锁的请求，在有些时候还是有必要的。

举个例子：如果你约好了和朋友一起去玩，结果等了1个小时，你朋友给你打电话说有突发情况不能去了。那么你一定扫兴的打道回府了。中断就类似于这么一套机制。如果一个线程正在等待锁，那么它依然可以收到一个通知，被告知无须再等待，可以停止工作了。这种情况对处理死锁是有一定帮助的。

下面的代码产生了一个死锁，我们通过重入锁的中断，可以有效地解决这个问题。

package com.example.test;

import java.util.concurrent.locks.ReentrantLock;

/**

* Created by sql_j on 2018/3/18.

*/

public class IntLockimplements Runnable {

public static ReentrantLocklock1 =new ReentrantLock();

public static ReentrantLocklock2 =new ReentrantLock();

int lock;

public IntLock(int lock){

this.lock = lock;

}

@Override

    public void run() {

try {

if(lock==1){

lock1.lockInterruptibly();

try {

Thread.sleep(1000);

}catch (InterruptedException e) {

e.printStackTrace();

}

lock2.lockInterruptibly();

System.out.println("我是线程1");

}else{

lock2.lockInterruptibly();

try {

Thread.sleep(1000);

}catch (InterruptedException e) {

e.printStackTrace();

}

lock1.lockInterruptibly();

System.out.println("我是线程2");

}

}catch (Exception e) {

e.printStackTrace();

}finally {

if(lock1.isHeldByCurrentThread()){

lock1.unlock();

}

if(lock2.isHeldByCurrentThread()){

lock2.unlock();

}

}

}

public static void main(String[] args){

IntLock intLock1 =new IntLock(1);

IntLock intLock2 =new IntLock(2);

Thread thread1 =new Thread(intLock1);

Thread thread2 =new Thread(intLock2);

thread1.start();

thread2.start();

try {

Thread.sleep(1000);

}catch (InterruptedException e) {

e.printStackTrace();

}

thread1.interrupt();

}

}

线程thread1和线程thread2启动后， thread1先占用lock1 再占用lock2；thread2先占用lock2 再占用lock1，很容易形成 两个线程相互等待。这里用lickInterruptibly()方法。这个方法可以在等待锁的过程中，响应中断。

 

 

 

3.trylock()

我们可以用trylock()方法进行限时等待。

 

 

public class IntLockimplements Runnable {

public static ReentrantLocklock1 =new ReentrantLock();

@Override

    public void run() {

try {

try {

if(lock1.tryLock(3, TimeUnit.SECONDS)){

Thread.sleep(6000);

}else{

System.out.println("get lock feild");

}

}catch (InterruptedException e) {

e.printStackTrace();

}

}catch (Exception e) {

e.printStackTrace();

}finally {

if(lock1.isHeldByCurrentThread()){

lock1.unlock();

}

}

}

}

 

我们同样开启两个线程，这时候 trylock()，会在3S内试着去请求锁，请求不到 就会返回false。

 

ReentrantLock.tryLock();方法也可以不带参数直接运行。

 

 

3.公平锁

我们在平时的应用中就知道，在大多数情况下，锁的申请是非公平的，无序的。这就好比，买票不要排队，谁能挤到最前面，谁就先买到票。而公平锁，是按照时间顺序来排队的，它不会产生饥饿现象，只要你排队，就一定能得到资源。如果我们使用synchronized关键字进行锁的控制，那它就是非公平的。

 

示例：

 

public static ReentrantLock fireLock = new ReentrantLock(true);

    @Override

    public void run() {

        try {

            try {

                if(fireLock.tryLock(3, TimeUnit.SECONDS)){

                }else{

                    System.out.println("get lock feild");

                }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if(fireLock.isHeldByCurrentThread()){

                fireLock.unlock();

            }

        }

    }

 

 

 

4.重入锁的好搭档:Condition条件

Condition和 Object.wait()、Obejct.notify() 方法的作用是大致相同的。只不过，Condition是作用在ReentrantLock上，而Object.wait()、Obejct.notify() 是作用在 synchronized上的。

await():方法会使当前线程等待，同时释放当前锁，其它线程中使用signal()或signalAll()方法时，线程会重新获得锁，并继续执行。或者当线程被中断时，也能跳出等待。

awaitUninteerrupibly():和await()方法类似，但是不会在等待响应过程中被中断。

signal():用于唤醒一个在等待中的线程。

signalAll():用于唤醒所有在等待的线程。

示例:

package com.example.test;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

/**

* Created by sql_j on 2018/3/18.

*/

public class IntLockimplements Runnable {

private static ReentrantLocklock =new ReentrantLock(true);

private static Conditioncondition =lock.newCondition();

@Override

    public void run() {

try {

lock.lock();

condition.await();

System.out.println("执行");

}catch (InterruptedException e) {

e.printStackTrace();

}finally {

if(lock.isHeldByCurrentThread()){

lock.unlock();

}

}

}

public static void main(String[] args){

IntLock intLock =new IntLock();

Thread thread =new Thread(intLock);

thread.start();

try {

Thread.sleep(3000);

}catch (InterruptedException e) {

e.printStackTrace();

}

lock.lock();

condition.signal();

lock.unlock();

}

}

 

5.对于ReentrantLock的应用整理如下

    lock():获得锁，如果锁被占用，则等待。

    lockInterruptibly():获得锁，但优先响应中断。

    tryLock():尝试获得锁，如果成功，返回true，失败返回false。该方法不等待，立即返回。

    tryLock(long time,TimeUnit unit):在给定时间内尝试获得锁。

    unlock():释放锁。