可重入锁的正确姿势

package Thread2;

/**
 * 可重入锁示例
 */
public class ReenTranLockDemo {
    private Object currentThread;
    private int lockTimes = 0;
    public synchronized void lock() throws InterruptedException {
        while (Thread.currentThread() == currentThread || currentThread == null || lockTimes > 0) {
            if (Thread.currentThread() == currentThread) {
                //当前线程重复加锁
                lockTimes++;
                System.out.println(1);
                System.out.println(currentThread);
                return;
            } else if (currentThread == null) {
                //当前线程首次加锁
                currentThread = Thread.currentThread();
                lockTimes++;
                System.out.println(2);
                System.out.println(currentThread);
                return;
            } else {
                //锁已被占用，当前线程进入等待
                wait();
                System.out.println(3);
                System.out.println(currentThread);
            }
        }
        System.out.println("lockTime:" + lockTimes);
        return;
    }
    public synchronized void unlock() {
        if (currentThread != null && Thread.currentThread() == currentThread) {
            if (1 == lockTimes) {
                currentThread = null;
                notify();
                System.out.println(4);
                System.out.println(currentThread);
            } else {
                System.out.println(5);
                System.out.println(currentThread);
            }
            lockTimes--;
        }
        System.out.println("lockTime:" + lockTimes);
    }


}

package Thread2;

public class RunReenTranLock3 {
    private static int a;
    private static int b;
    private static ReenTranLockDemo reenTranLockDemo = new ReenTranLockDemo();
    private static ReenTranLockDemo reenTranLockDemo1 = new ReenTranLockDemo();
    public static void main(String[] args) throws InterruptedException {
        Thread thread = getThread();
        Thread thread1 = getThread();
        Thread thread2 = getThread1();
        thread.start();
        thread1.start();
        thread2.start();
        thread.join();
        thread1.join();
        thread2.join();
        System.out.println("a:" + a);
        System.out.println("b:" + b);
    }

    public static Thread getThread() {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    reenTranLockDemo.lock();
                    for (int i = 0; i < 10000; i++) {
                        a++;
                    }
                    method1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reenTranLockDemo.unlock();
                }
            }
        });
        return thread;
    }
    public static Thread getThread1() {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    reenTranLockDemo1.lock();
                    for (int i = 0; i < 10000; i++) {
                        b++;
                    }
                    method2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reenTranLockDemo1.unlock();
                }
            }
        });
        return thread;
    }

    public static void method1() throws InterruptedException {
        reenTranLockDemo.lock();
        try {
            for (int i = 0; i < 10000; i++) {
                a++;
            }
        } finally {
            reenTranLockDemo.unlock();
        }
    }

    public static void method2() throws InterruptedException {
        reenTranLockDemo1.lock();
        try {
            for (int i = 0; i < 10000; i++) {
                b++;
            }
            method3();
        } finally {
            reenTranLockDemo1.unlock();
        }
    }
    public static void method3() throws InterruptedException {
        reenTranLockDemo1.lock();
        try {
            for (int i = 0; i < 10000; i++) {
                b++;
            }
        } finally {
            reenTranLockDemo1.unlock();
        }
    }
}

测试结果

2
Thread[Thread-0,5,main]
2
Thread[Thread-2,5,main]
1
Thread[Thread-0,5,main]
1
Thread[Thread-2,5,main]
5
Thread[Thread-0,5,main]
1
Thread[Thread-2,5,main]
5
Thread[Thread-2,5,main]
lockTime:2
5
lockTime:1
Thread[Thread-2,5,main]
4
null
lockTime:1
lockTime:0
4
null
3
null
2
lockTime:0
Thread[Thread-1,5,main]
1
Thread[Thread-1,5,main]
5
Thread[Thread-1,5,main]
lockTime:1
4
null
lockTime:0
a:40000
b:30000