Significance of use of keyword synchronized in the following code

I was reading multi threading in Java from the book Java The Complete Reference by Herbert Schildt. I came across following code [Pg. 252, 7th ed.] that explained the usage of wait() and notify() to suspend and resume threads in modern Java. My question is regarding the significance of the keyword synchronization at two places in following code (in run() method of class NewThread):

// Suspending and resuming a thread the modern way.
class NewThread implements Runnable {
	String name;
	Thread t;
	boolean suspendFlag;
	NewThread(String threadname) {
		name = threadname;
		t = new Thread(this, name);
		suspendFlag = false;
		t.start();
	}
// This is the entry point for thread.
	public void run() {
		try {
			for (int i = 15; i > 0; i--) {
				System.out.println(name + ": " + i);
				Thread.sleep(200);
				synchronized (this) { //First doubt here
					while (suspendFlag) {
						wait();
					}
				}
			}
		} catch (InterruptedException e) {
			System.out.println(name + " interrupted.");
		}
		System.out.println(name + " exiting.");
	}
	void mysuspend() {
		suspendFlag = true;
	}
	synchronized void myresume() { //Second doubt here
		suspendFlag = false;
		notify();
	}
}

class SuspendResume {
	public static void main(String args[]) {
		NewThread ob1 = new NewThread("One");
		NewThread ob2 = new NewThread("Two");
		try {
			Thread.sleep(1000);
			ob1.mysuspend();
			Thread.sleep(1000);
			ob1.myresume();
			ob2.mysuspend();
			Thread.sleep(1000);
			ob2.myresume();
		} catch (InterruptedException e) {
			System.out.println("Main thread Interrupted");
		}
        //some code
}

My doubt here: I know about the use of keyword synchronization i.e. allowing only one thread to enter a synchronized method on the same object but here we have two threads running on two different objects. So what is the significance of both synchronization keywords used in above code.

I tried running the above code by removing the synchronized keyword at each place differently and simultaneously. I am getting the same error: java.lang.IllegalMonitorStateException: current thread is not owner different number of times and at different line numbers depending upon if I remove both or only one (and which one) synchronization keyword. I looked for the above error and found an explanation for it here but still couldn't connect the answer to my doubt.

The problem that synchronized solves is, it allows the two threads to have a consistent view of the shared suspendFlag variable.

In some real program, a thread might set other shared variables before setting susependFlag=false. If synchronized was not used, then the waiting thread could wake up, and see suspendFlag==false, but not see the other variables set. Or worse, it could see some of them set, but not others.

Without synchronization, Java does not guarantee that different threads will see variables updated in the same order.

> I am getting the same error: java.lang.IllegalMonitorStateException: current thread is not owner.

The Java library is trying to help you by forcing you to use synchronized before it will allow you to use wait() and notify(). The rule is simple: You can only call o.wait() or o.notify() or o.notifyAll() from code that is inside a synchronized(o) block. If you break that rule, then the library throws the exception.

When your code calls o.wait() the wait() call temporarily unlocks the monitor lock so that the other thread will be able to synchronize on o and call o.notify(). The o.wait() call is guaranteed to re-lock o before it returns.