一个线程执行synchronized同步代码时，再次重入该锁过程中，如果抛出异常，会释放锁吗？

如果锁的计数器为1，抛出异常，会直接释放锁；

那如果锁的计数器为2，抛出异常，会直接释放锁吗？

来简单测试一下

@Slf4j
public class SynchronizedExceptionRunnable implements Runnable {

    private volatile boolean flag = true;

    @Override
    public void run() {
        synchronized (this) {
            if (flag) {
                //让先启动的线程先执行异常方法methodB后，flag==false，并且抛出异常线程停止，直接释放锁，不会执行后面的代码；
                methodB();
            } else {
                //后启动的线程再获取锁，进入if-else,再获取锁执行methodA
                methodA();
            }
            log.info("{}:if-else end!",Thread.currentThread().getName());
        }
    }

    public synchronized void methodA(){
        log.info("ThreadName:{}----methodA", Thread.currentThread().getName());
    }

    public synchronized void  methodB() {
        flag = false;
        log.warn("ThreadName:{}----methodB will throw a exception!",Thread.currentThread().getName());

        //如果把下面这行抛异常的代码注释掉，会执行下面的线程睡眠5秒和最后的日志代码
        //如果不注释，会抛出异常，不在执行后面的代码，并且释放锁，methodA方法就会执行
        int a = 1/0;


        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("ThreadName:{}----methodB End!",Thread.currentThread().getName());
    }
}

启动类

public class Main {
    public static void main(String[] args) {
        SynchronizedExceptionRunnable runnable = new SynchronizedExceptionRunnable();

        Thread thread1 = new Thread(runnable,"杯子");
        Thread thread2 = new Thread(runnable,"人");
        thread1.start();
        thread2.start();
    }
}