演示ReetrantLock锁的Maximum lock count exceeded问题

Posted 2021-12-22 Dream_it_possible！

 

目录

情景再现

解决办法

---

      我们在工作中，有些场景下可能会用到ReetrantLock, 他是一个独占式的锁，如果使用不当，我们可能会遇到报Maximum lock count exceeded的移除，此异常式一个典型的溢出问题。

情景再现

        我们可以根据异常找到报错的地方，然后打个断点，在此写了一个例子，用来演示此问题, 原理如下:

        开启三个线程，在执行的时候加锁，然后不释放，直到报错。

package com.example.jucdemo.lock;

import java.util.concurrent.locks.ReentrantLock;

// 演示Maximum lock count exceeded问题
public class ReentrantLockDemo 

    private static ReentrantLock lock = new ReentrantLock();

    private static int num = 5;

    public static void main(String[] args) 

        Thread t1 = new Thread(new Bread());
        Thread t2 = new Thread(new Bread());
        Thread t3 = new Thread(new Bread());
        t1.start();
        t2.start();
        t3.start();

    


    static class Bread implements Runnable 


        @Override
        public void run() 

            while (true) 
                lock.lock();
                if (num > 0) 
                    System.out.println(Thread.currentThread().getName() + "排队取面包");
                    num--;
                    System.out.println("面包数量=" + num);
//                    try 
                        Thread.sleep(100);
//                     catch (InterruptedException e) 
//                        e.printStackTrace();
//                    
                
            
        
    

        在此先看一个lock()方法里的实现，因为ReetrantLock的lock底层实现是acquire()方法: 

 然后执行tryAcquire()方法没有成功的前提下， 会执行acquireQueued()方法和addWaiter()方法。

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

         addWaiter在我之前的文章里介绍过，简单讲就是讲节点添加到同步等待队列里，可以参考:

深入理解AbstractQueuedSynchronizer(一)_ Dream_it_possible！的博客-CSDN博客

        addWaiter执行完后会执行acquireQueued()方法，该方法实现了一个自选阻塞，每次从同步队列里拿节点，然后去tryAcquire()

         在ReentrantLock里的非公平锁tryacquire实现如下: 当同一个线程再次拿到exclusiveOwnerThread里的线程进行比较，是有可能和自己相等的。举个栗子，有Thread0头次加锁的时候会把Thread0设置到exclusiveOwnerThread里，然而此时的独占锁并没有释放，而Thread0再次过来拿锁，那么就会出问题了，不断的拿锁会导致state值一直增加,因为setState(nextc)方法重新设置了state,如下图: 

        当nextc的值达到2147483648时，那么值溢出，就会抛出异常:Maximum lock count exceeded!

         最终惊奇的出现了负值，然后报错出现如下问题：

解决办法

        用完锁后当前线程，在此不考虑分布式的情况，及时的把锁给释放掉就行。

package com.example.jucdemo.lock;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

// 演示Maximum lock count exceeded问题
public class ReentrantLockDemo 

    private static ReentrantLock lock = new ReentrantLock();

    private static AtomicInteger num = new AtomicInteger(5);

    public static void main(String[] args) 

        Thread t1 = new Thread(new Bread());
        Thread t2 = new Thread(new Bread());
        Thread t3 = new Thread(new Bread());
        t1.start();
        t2.start();
        t3.start();

    


    static class Bread implements Runnable 


        @Override
        public void run() 

            while (true) 
                lock.lock();
                if (num.get() > 0) 
                    num.decrementAndGet();
                    System.out.println(Thread.currentThread().getName() + "排队取面包");
                    System.out.println("面包数量=" + num);
                    try 
                        Thread.sleep(100);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                     finally 
                        lock.unlock();
                    
                 else 
                    lock.unlock();
                    break;
                
            
        
    

        打印结果: