ReentrantLock详解

 

ReenTrantLock可重入锁和synchronized的区别

1)可重入性：

从名字上理解，ReenTrantLock的字面意思就是再进入的锁，其实synchronized关键字所使用的锁也是可重入的，两者关于这个的区别不大。两者都是同一个线程没进入一次，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

2)锁的实现：

Synchronized是依赖于JVM实现的，而ReenTrantLock是JDK实现的，有什么区别，说白了就类似于操作系统来控制实现和用户自己敲代码实现的区别。前者的实现是比较难见到的，后者有直接的源码可供阅读。

3)性能的区别：

在Synchronized优化以前，synchronized的性能是比ReenTrantLock差很多的，但是自从Synchronized引入了偏向锁，轻量级锁（自旋锁）后，两者的性能就差不多了，在两种方法都可用的情况下，官方甚至建议使用synchronized，其实synchronized的优化我感觉就借鉴了ReenTrantLock中的CAS技术。都是试图在用户态就把加锁问题解决，避免进入内核态的线程阻塞。

4)功能区别：

便利性：很明显Synchronized的使用比较方便简洁，并且由编译器去保证锁的加锁和释放，而ReenTrantLock需要手工声明来加锁和释放锁，为了避免忘记手工释放锁造成死锁，所以最好在finally中声明释放锁。

锁的细粒度和灵活度：很明显ReenTrantLock优于Synchronized

 

ReenTrantLock独有的能力：

1.      ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。

2.      ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。

3.      ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

 

 

 

使用场景

package com.zqr;

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

/**
 * Created by uisftech on 2018/5/2.
 */
public class ReentrantLockTest
{
    //默认非公平锁，效率高
    public static ReentrantLock nofairLock = new ReentrantLock();
    //设置公平锁
    private ReentrantLock fairLock = new ReentrantLock(true);

    /**
     *  一.  nofairLock.lock();
     *      使用场景：同步操作 当其他的线程占有锁时,则会阻塞等待锁释放,达到暂停的效果.
     *               类似于synchronized
     *               ReentrantLock存在公平锁和非公平锁，而synchronized只有公平锁.
     */
    public static void lockTest(){
        try {
            //如果锁被其它线程找有,则会在此等待锁释放,处于暂停状态.
            nofairLock.lock();
            //操作
            System.out.println("======Method:locktTest:"+Thread.currentThread().getName()+"======");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            nofairLock.unlock();
        }
    }


    /**
     *  二.   nofairLock.tryLock()
     *        使用场景:(1)比如一个定时任务,第一次定时任务未完成,重复发起了第二次,直接返回flase;
     *                (2)用在界面交互时点击执行较长时间请求操作时，防止多次点击导致后台重复执行
     */
    public static  void  tryLockTest(){
        //  如果操作正在进行,对象锁已经被占有,tryLock()返回false,放弃等待,达到忽略操作的效果.
        if (nofairLock.tryLock()){
            try {
                //操作
                System.out.println("======Method:tryLockTest:"+Thread.currentThread().getName()+"======");

            }finally {
                nofairLock.unlock();
            }
        }
    }

    /**
     *  三.  nofairLock.tryLock(5, TimeUnit.SECONDS))
     *       使用场景:(1)如果发现该操作正在执行,等待一段时间，如果规定时间未得到锁,放弃。
     *                  防止资源处理不当，线程队列溢出,出现死锁
     */
    public static void tryLockTimeTest(){
        try {
            //如果已经被lock,则尝试等待5秒钟,看是否可以获得锁;
            //  如果5秒后还未获得锁,则返回false跳过操作
            if (nofairLock.tryLock(5, TimeUnit.SECONDS)){
                try {
                    //操作
                    System.out.println("======Method:tryLockTimeTest:"+Thread.currentThread().getName()+"======");
                } finally {
                    nofairLock.unlock();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     *  四.  nofairLock.lockInterruptibly()
     *      使用场景: 中断正在进行的操作,释放锁,进行下一操作.
     *              比如:取消正在同步运行的操作,来防止不正常操作长时间占用造成的阻塞.
     */
    public static void lockInterruptTest(){
        try {
            nofairLock.lockInterruptibly();
            //操作
            System.out.print("======Method:lockInterruptTest:"+Thread.currentThread().getName()+"======");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args){
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    tryLockTest();
                }
            }).start();
        }
    }
}