ReentrantLock详解

于 2019-09-17 22:33:19 发布
阅读量176 收藏
点赞数
分类专栏： java 文章标签： 锁 ReentrantLock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GitYang/article/details/100942140
版权

ReentrantLock实现方式与Synchronized实现方式对比

1.ReentrantLock实现

public static void main(String[] args) {

    ReentrantLock lock = new ReentrantLock();

    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {//通过for循环确定ReentrantLock是可重入锁
                lock.lock();
                System.out.println("t1-lock-" + i);
            }

            for (int i = 0; i < 3; i++) {
                lock.unlock();
                System.out.println("t1-unlock-" + i);
            }
        }
    });

    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {
                lock.lock();
                System.out.println("t2-lock-" + i);
            }

            for (int i = 0; i < 3; i++) {
                lock.unlock();
                System.out.println("t2-unlock-" + i);
            }
        }
    });

    t1.start();
    t2.start();
}

2.Synchronized实现

public static void main(String[] args) {
    Object obj = new Object();
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (obj) {
                for (int i = 0; i < 3; i++) {
                    synchronized (obj) {
                        System.out.println("t1-lock-" + i);
                    }
                }
                for (int i = 0; i < 3; i++) {
                    synchronized (obj) {
                        System.out.println("t1-unlock-" + i);
                    }
                }
            }
        }
    });

    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (obj) {
                for (int i = 0; i < 3; i++) {
                    synchronized (obj) {
                        System.out.println("t2-lock-" + i);
                    }
                }
                for (int i = 0; i < 3; i++) {
                    synchronized (obj) {
                        System.out.println("t2-unlock-" + i);
                    }
                }
            }
        }
    });

    t1.start();
    t2.start();
}

上述两种方式执行结果一致，可能打印的两种执行结果如下：

t2-lock-0
t2-lock-1
t2-lock-2
t2-unlock-0
t2-unlock-1
t2-unlock-2
t1-lock-0
t1-lock-1
t1-lock-2
t1-unlock-0
t1-unlock-1
t1-unlock-2

或

t1-lock-0
t1-lock-1
t1-lock-2
t1-unlock-0
t1-unlock-1
t1-unlock-2
t2-lock-0
t2-lock-1
t2-lock-2
t2-unlock-0
t2-unlock-1
t2-unlock-2

独占性：线程t1和线程t2竞争锁，先获取到锁的线程执行完并释放锁后，另一个线程才能执行
可重入性：线程中的循环方法可以多次获取锁，然后在对锁进行相同次数的释放。
ReentrantLock与Synchronized的区别：
两者性能差别不大，主要区别在于使用方式。

  1. ReentranLock使用起来较灵活，而且提供了很多其他好用的方法，但是获取锁和释放锁需要分别执行。
  2. Synchronized使用起来较简单（某些场景反而有些不太灵活），锁的获取和释放均是隐式实现的。

其他区别1：公平锁和非公平锁

  • ReentranLock默认情况下和Synchonized一样，实现方式是非公平锁，即锁释放后线程随机获取到锁，无论线程等待时间长短，获取锁的机会相同。相较于公平锁，非公平锁的性能会更好一些。
public static void main(String[] args) throws InterruptedException {

//        ReentrantLock lock = new ReentrantLock(false); //非公平锁
        ReentrantLock lock = new ReentrantLock(true);  //公平锁

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    lock.lock();
                    System.out.println("t1-lock-" + i);
                }
                try {
                    Thread.sleep(1000 * 5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 3; i++) {
                    lock.unlock();
                    System.out.println("t1-unlock-" + i);
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    lock.lock();
                    System.out.println("t2-lock-" + i);
                }

                for (int i = 0; i < 3; i++) {
                    lock.unlock();
                    System.out.println("t2-unlock-" + i);
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 3; i++) {
                    lock.lock();
                    System.out.println("t3-lock-" + i);
                }

                for (int i = 0; i < 3; i++) {
                    lock.unlock();
                    System.out.println("t3-unlock-" + i);
                }
            }
        });
        //通过休眠使得t1线程在执行未结束时，t2和t3线程已经处于阻塞状态，并且t2比t3阻塞是将长
        t1.start();
        Thread.sleep(1000);
        t2.start();
        Thread.sleep(1000);
        t3.start();
    }

使用公平锁之后的打印结果（一种打印结果）：

t1-lock-0
t1-lock-1
t1-lock-2
t1-unlock-0
t1-unlock-1
t1-unlock-2
t2-lock-0
t2-lock-1
t2-lock-2
t2-unlock-0
t2-unlock-1
t2-unlock-2
t3-lock-0
t3-lock-1
t3-lock-2
t3-unlock-0
t3-unlock-1
t3-unlock-2

使用非公平锁之后的打印结果（两种打印结果）：
第一种打印结果同上。
第二种打印结果：

t1-lock-0
t1-lock-1
t1-lock-2
t1-unlock-0
t1-unlock-1
t1-unlock-2
t3-lock-0
t3-lock-1
t3-lock-2
t3-unlock-0
t3-unlock-1
t3-unlock-2
t2-lock-0
t2-lock-1
t2-lock-2
t2-unlock-0
t2-unlock-1
t2-unlock-2

其他区别2：处理死锁

  1. 使用synchronized实现锁时，除非线程获取到锁，否则将会一直等待下去。
  2. 使用ReentrantLock实现锁时，可以使用lockInterruptibly()方法响应中断的获取锁
public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock1 = new ReentrantLock();
        ReentrantLock lock2 = new ReentrantLock();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //lock1.lock();
                    lock1.lockInterruptibly();
                    System.out.println("t1-lock1");
                    Thread.sleep(1000);//等待1s
                    //lock2.lock();
                    lock2.lockInterruptibly();
                    System.out.println("t1-lock2");
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    lock1.unlock();
                    System.out.println("t1-unlock1");
                    lock2.unlock();
                    System.out.println("t1-unlock2");
                    System.out.println("t1正常完成");
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock2.lock();
                    System.out.println("t2-lock2");
                    Thread.sleep(1000);
                    lock1.lock();
                    System.out.println("t2-lock1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock2.unlock();
                    System.out.println("t2-unlock2");
                    lock1.unlock();
                    System.out.println("t2-unlock1");
                }
                System.out.println("t2正常完成");
            }
        });
        t1.start();
        t2.start();
        Thread.sleep(2000);//等待2s
        t1.interrupt();
    }

打印结果：

t1-lock1
t2-lock2
java.lang.InterruptedException
		at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
		at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
at java.lang.Thread.run(Thread.java:745)
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
		at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
		at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
		at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
		at java.lang.Thread.run(Thread.java:745)
t1-unlock1
t2-lock1
t2-unlock2
t2-unlock1
t2正常完成

使用ReentrantLock实现锁时，如果我们不使用lockInterruptibly()方法，仍然继续执行t1.interrupt()，会发生什么呢？

public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock1 = new ReentrantLock();
        ReentrantLock lock2 = new ReentrantLock();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock1.lock();
//                    lock1.lockInterruptibly();
                    System.out.println("t1-lock1");
                    Thread.sleep(1000);//等待1s
                    lock2.lock();
//                    lock2.lockInterruptibly();
                    System.out.println("t1-lock2");
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    lock1.unlock();
                    System.out.println("t1-unlock1");
                    lock2.unlock();
                    System.out.println("t1-unlock2");
                    System.out.println("t1正常完成");
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock2.lock();
                    System.out.println("t2-lock2");
                    Thread.sleep(1000);
                    lock1.lock();
                    System.out.println("t2-lock1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock2.unlock();
                    System.out.println("t2-unlock2");
                    lock1.unlock();
                    System.out.println("t2-unlock1");
                }
                System.out.println("t2正常完成");
            }
        });
        t1.start();
        t2.start();
        Thread.sleep(2000);//等待2s
        t1.interrupt();
        System.out.println("t1.interrupt()已执行");
}

打印结果：

t1-lock1
t2-lock2
t1.interrupt()已执行
（进入死锁状态）

为什么会发生这种情况呢？我们不是已经执行了t1.interrupt()方法吗？
我们来看一下interrupt()方法源码中的注释是怎么说的：

  1. 除非当前线程中断自身(这是总是允许的)，否则将调用该线程的checkAccess方法，这可能导致抛出SecurityException。
  2. 如果这个线程被阻塞的调用wait()、wait(long)、wait(long, int) 、join()、join(long)、join(long,int)、sleep()、sleep(long)、sleep(long,int)方法,那么它的中断状态将被清除,它将收到一个InterruptedException。
  3. 如果该线程在可阻止在I / O操作 java.nio.channels.InterruptibleChannel InterruptibleChannel,则该通道将被关闭，该线程的中断状态将被设并且该线程将收到java.nio.channels.ClosedByInterruptException。
  4. 如果这个线程在java.nio.channels中被阻塞。然后线程的中断状态将被设置，它将立即从选择操作返回，可能带有一个非零值，就像选择器的 java.nio.channels一样方法被调用
  5. 如果前面的条件都不成立，那么这个线程的interrupt的status将被设置。
  6. 中断非活动的线程不一定会产生任何效果。

那我们看一下当线程获取不到锁时，会处于什么状态呢？
我们来看一下lock()方法的注释说明：

  • 获得锁。如果锁没有被其他线程持有，则>获取锁，并立即返回*，将锁持有计数设置为1。如果当前线程已经持有锁，那么持有计数将增加1，方法立即返回。如果锁被另一个线程持有，那么为了线程调度的目的，当前线程将被禁用，并处于休眠状态，直到锁被获取，此时锁持有计数被设置为1

**从上面的注释中我们可以了解到，线程获取不到锁会处于休眠状态，那这个所谓的休眠状态是不是和sleep()方法的休眠是一样的呢？**后续我们在继续跟一下源码补充在此处。

御陽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值