想自己编写一个线程死锁产生的例子，加深对synchronize的理解，但是发现了这个，理解不了

Question

我的思路：
在一个类中弄两个个方法，一个A，B都加锁，要想A要得到B，B也想得到A，这样就能产生死锁。因为是同一个类，所以为了能使线程调用方法A和方法B，需要在run方法中对两个方法都调用一次，单一 一个线程按照顺序调用A、B方法就会陷入死循环，所以我用了一下方式，但还是陷入了死循环，谁能解释一下，我能得到的结论就是synchronized修饰的方法是把整个类中所有带有synchronized修饰方法都上锁了，是不是啊？

 public class SynchronizedLocked_Dead implements Runnable {
    private static int num = 0 ;
    public synchronized void get1(){
            System.out.println(Thread.currentThread().getName()+",调用1");
            //准备创建两个线程，让线程1跳过getP()方法，然后线程2进来直接进入getP()方法
            num++;
            if(num>1){
                getP();
            }
    }
    public synchronized void getP(){
        System.out.println(Thread.currentThread().getName()+"这是P：");
        //为了让线程1执行完get1方法后，睡着，好让线程2能够顺利抢占到get1方法，
        //并且等待线程1释放getP()方法
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程1睡醒就想运行get1方法，但是此时线程2应该还在get1方法中等待getP方法释放
        //此时线程1又想获取线程2中的getP方法，所有陷入死锁
        get1();
    }


    @Override
    public void run() {
        System.out.println("");
        System.out.println(Thread.currentThread().getName()+"进来了");
        System.out.println("");

        get1();
        getP();
    }
    public static void main(String[] args) {
        SynchronizedLocked_Dead me = new SynchronizedLocked_Dead();
        new Thread(me,"t1").start();
        new Thread(me,"t2").start();
    }

}

运行结果：
t1进来了

t1,调用1
t1这是P：
t2进来了//就这一下下就没了？

t1,调用1
t1这是P：
t1,调用1
t1这是P：
t1,调用1
t1这是P：
t1,调用1
t1这是P：
......................死循环

Answer 1

首先说明一下，这个synchronised关键字在不加static修饰符的情况下，锁的是当前对象而非类， 显然你的用例中锁的是对象。然后你两个线程开始
跑呀跑，运气好的就像你用例中的t1取到了锁，锁住了当前对象，然后在两个方法中循环，当前对象一直被锁着，t2线程拿不到当前对象，一直在等。
就造成你现在看到 的样子。