锁重入

package com.roocon.thread.t6;

public class Demo {
    /*
    当第一个线程A拿到当前实例锁后，进入a方法，那么，线程A还能拿到被当前实例所加锁的另一个
    同步方法b吗？是不是只有当线程A释放了a方法的同步锁后，才可以去获取b方法的同步锁呢？
     */
    public synchronized void a(){
        System.out.println("a");
        b();
    }

    public synchronized void b(){
        System.out.println("b");
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo demo = new Demo();
                demo.a();
            }
        }).start();
    }
}

运行结果：

a
b

以上结果说明，线程A在释放方法a的同步锁之前，是可以重新获得b方法的同步锁的。同一个线程拿到同一个对象的锁，它是可以进入另一个同步方法的，这就是锁的重入。以上代码仅仅是同一个线程在一个同步方法中去成功调用另一个同步方法，并且，锁的是同一个实例。那么，不同的线程拿同一把对象去加锁，会怎样进行呢？

package com.roocon.thread.t6;

public class Demo {
    /*
    当第一个线程A拿到当前实例锁后，进入a方法，那么，线程A还能拿到被当前实例所加锁的另一个
    同步方法b吗？是不是只有当线程A释放了a方法的同步锁后，才可以去获取b方法的同步锁呢？
     */
    public synchronized void a(){
        System.out.println("a");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void b(){
        System.out.println("b");
        try {
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        //Demo demo1 = new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.a();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.b();
            }
        }).start();
    }
}

运行结果：

a
b

虽然以上运行结果还是a b，但是，由于锁的是同一个实例，所以，在输出a之后，要等待5s才会输出b。若将以上代码修改为如下，锁的不是同一个实例：

package com.roocon.thread.t6;

public class Demo {
    /*
    当第一个线程A拿到当前实例锁后，进入a方法，那么，线程A还能拿到被当前实例所加锁的另一个
    同步方法b吗？是不是只有当线程A释放了a方法的同步锁后，才可以去获取b方法的同步锁呢？
     */
    public synchronized void a(){
        System.out.println("a");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void b(){
        System.out.println("b");
        try {
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        Demo demo1 = new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.a();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.b();
            }
        }).start();
    }
}

运行结果：

a
b

a b几乎是同时输出的。

以上两个代码说明，如果多个线程同时去执行同步方法，如果锁的是同一个实例，那么必须等当前这个同步方法释放锁后，才可以去获取另一个同步锁方法。

而如果锁的不是同一个实例，那么，两个同步方法几乎是可以同时执行。有了以上基础，那么再来理解以下代码，就很简单了。

package com.roocon.thread.t6;

public class Demo {

    public synchronized void a(){
        System.out.println("a");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("print b()");
        b();
    }

    public synchronized void b(){
        System.out.println("b");
        try {
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.a();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.b();
            }
        }).start();
    }
}

运行结果：

a
print b()
b
b

以上结果，先输出a，过了5s后再输出print b()  b，再过了8s输出b，也就是，由于锁的是同一个实例，所以，只有线程1当a方法调用完毕后，线程2才可以获取该实例锁进入b方法。