How to check deadlock in this example

currently I am learning deadlock and I found a example of deadlock but I don't get how deadlock is occurring in this example.

public class Main {
public static void main(String[] args) {
final PolitePerson jane = new PolitePerson("Jane");
final PolitePerson john = new PolitePerson("John");
new Thread(new Runnable() {
@Override
public void run() {
jane.sayHello(john);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
john.sayHello(jane);
}
}).start();
}
static class PolitePerson {
private final String name;
public PolitePerson(String name) {
this.name = name;
}
public String getName() {
return name;
}
public synchronized void sayHello(PolitePerson person){
System.out.format("%s: %s" + " has said hello to me!%n", this.name, person.getName());
person.sayHelloBack(this);
}
public synchronized void sayHelloBack(PolitePerson person) {
System.out.format("%s: %s" + " has said hello back to me!%n", this.name, person.getName());
}
}
}

I spend more then one hour understanding how things are happening here but didn't got it.
here is the output which I am getting

Jane: John has said hello to me!
John: Jane has said hello to me!

or maybe I misunderstood synchronisation here.

A method marked with synchronized locks the critical-section (the method) using this as the lock. To enter a critical section (and lock it), a thread needs to acquire the corresponding lock. If the section is already locked, the thread is blocked at the entrance and waits for the lock to be released.

A and B are threads:

• A calls jane.sayHello(john) and locks jane.
• B calls john.sayHello(jane) and locks john.

Notice that sayHello is marked with synchronized.

• A calls person.sayHelloBack(this), where person is john.
• B calls person.sayHelloBack(this), where person is jane.

Notice that sayHelloBack is also marked with synchronized.

• B holds john, so A's call john.sayHelloBack is blocked.

• A holds jane, so B's call jane.sayHelloBack is blocked.

• A is waiting for B to release the lock and vice versa.

• Deadlock.

When we mark a method as synchronized, it takes a lock on the current object. So, the first thread takes a lock on the object jane whereas the second thread takes lock on the object john, as soon as it calls the method sayHello().

As you have marked the sayHelloBack() also as synchronized, it would wait until the other thread releases lock on the invoking object. For the first thread, it calls john.sayHelloBack(), it tries to acquire lock on john - but it has already been acquired by thread-2. For the second thread, it calls jane.sayHellpBack(), it tries to acquire lock on jane - but it is already acquired by thread-1.

So, both the threads keep waiting for the lock at that point causing the deadlock.