java可重入锁示例

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 RunReenTranLock {
    private static int a =0;
    public static void main(String[] args) throws InterruptedException {
        ReenTranLockDemo reenTranLockDemo = new ReenTranLockDemo();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    reenTranLockDemo.lock();
                    try {
                        reenTranLockDemo.lock();
                        for (int i = 0; i < 10000; i++) {
                            a++;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        reenTranLockDemo.unlock();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reenTranLockDemo.unlock();
                }
            }
        });

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    reenTranLockDemo.lock();
                    try {
                        reenTranLockDemo.lock();
                        for (int i = 0; i < 10000; i++) {
                            a++;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        reenTranLockDemo.unlock();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reenTranLockDemo.unlock();
                }
            }
        });
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(a);
    }
}

测试结果

2
Thread[Thread-0,5,main]
1
Thread[Thread-0,5,main]
5
Thread[Thread-0,5,main]
lockTime:1
4
null
lockTime:0
3
null
2
Thread[Thread-1,5,main]
1
Thread[Thread-1,5,main]
5
Thread[Thread-1,5,main]
lockTime:1
4
null
lockTime:0
20000