In note #1,  keyword "synchronized" is used to synchronize threads. Keyword "synchronized"  is not the only way to synchronize threads in Java. Another way is to use methods wait and notify.  When a thread A encounters a wait method, it sleeps (becomes disabled). Thread  A stays in this state till another thread wakes it (thread A) using a notify method.

For example, a producer thread produces some items, and a consumer thread consumes these items. If there are no items, then the consumer waits (becomes disabled) till the producer notifies the consumer of the availability of items. Afterwards, the consumer becomes enabled and consumes the available items.

The following methods are available in class Object:

• notify():    Wakes up a single thread that is waiting on this object. A thread waits on an object by calling one of the wait methods: wait(), wait(long), and wait(long,int).
• notifyAll():    Wakes up all threads that are waiting on this object.
• wait():    Causes current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object.
• wait(long timeout):    Causes current thread to wait until either another thread invokes the notify() method or the notifyAll() method for this object, or a specified amount of time has elapsed.
• wait(long timeout, int nanos):    Causes current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.

Example 1
Example 1 is available at ExBound.java:

class ExBound {
    public static void main (String argv[]) {
        new Counter();
    }
}

// This class creates four threads, that share a common counter.
// Two threads repeat the following sequence for 25000 times:
//     - Reads the counter value into a variable temp.
//     - Increments temp by 1.
//     - Stores temp into counter.
//
// The other two threads repeat the following sequence for 25000 times:
//     - Reads the counter value into a variable temp.
//     - Decrements temp by 1.
//     - Stores temp into counter.
//
// There is an extra condition: "counter" stays within [0,100]. So, if
// a thread wants to increase "counter" while its value is 100, the thread has to
// wait till the value of "counter" becomes less than 100. Similarly, if a thread
// wants to decrement "counter" while its value is zero, the thread has to wait
// till the value of "counter" becomes bigger than zero.
//
// After incrementing "counter" for 50000 and decrementing "counter" 50000,
// the value of the counter is zero.
//
class Counter {
    Entity counter = new Entity();

    Counter(){
        IncThread th1 = new IncThread("th1");
        DecThread th2 = new DecThread("th2");
        IncThread th3 = new IncThread("th3");
        DecThread th4 = new DecThread("th4");

        th1.start();
        th2.start();
        th3.start();
        th4.start();
        System.out.println("Threads running.");
    }

    class DecThread extends Thread {
        String name;
        DecThread(String name){
            this.name = name;
        }
        public void run(){
            for (int i=0; i < 25000; i++){
                synchronized(counter){
                    try {
                        while (counter.counter <= 0)
                            counter.wait();
                    } catch (InterruptedException ie){
                        System.out.println("Monitor violated");
                    }

                    int temp = counter.counter;
                    yield();
                    temp = temp -1;
                    yield();
                    counter.counter = temp;
                    yield();
                    // Notify other threads that 0 < counter =< 100
                    if (counter.counter > 0)
                        counter.notifyAll();
                    if (counter.counter > 100 || counter.counter < 0)
                        throw new Error("Error: counter violates [0,100]");
                }
            }
            System.out.println(name + " counter = " + counter.counter);
        }
    }

    class IncThread extends Thread {
        String name;
        IncThread(String name){
            this.name = name;
        }
        public void run(){
            for (int i=0; i < 25000; i++){
                synchronized(counter){
                    try {
                        while (counter.counter >= 100)
                            counter.wait();
                    } catch (InterruptedException ie){
                        System.out.println("Monitor violated");
                    }
                    int temp = counter.counter;
                    yield();
                    temp = temp + 1;
                    yield();
                    counter.counter = temp;
                    yield();
                    // Notify other threads that 0 =< counter < 100
                    if (counter.counter < 100)
                        counter.notifyAll();
                    if (counter.counter > 100 || counter.counter < 0)
                        throw new Error("Error: counter violates [0..100]");
                }
            }
            System.out.println(name + " counter = " + counter.counter);
        }
    }
}

class Entity extends Object {
    // Initialize counter to zero. What happens if counter's value is outside
    // [0..100]?
    public int counter = 0;
}
 
 

This program is compiled using command "javac ExBound.java", and
is executed using command "java ExBound".

Notes about example 1:

• A thread cannot wait on an object that does not extend class Object (or extends any class that has extended class Object).
• wait/notify methods should only be called by a thread that is the owner of this object. A thread becomes the owner of the object in one of three ways (see notify description):
• By executing a synchronized instance method of that object.
• By executing the body of a synchronized statement that synchronizes on the object.
• For objects of type Class, by executing a synchronized static method of that class.
For example, an object of class DecThread waits on object counter of class Entity using counter.wait().  For this thread to use counter.wait(), it has to be the owner of the object by locking it using:
synchronized(counter) {
......
counter.wait();
.......
}
• When a thread calls counter.wait(), the thread puts itself on the waiting list of object counter, and then relinquishes all synchronization claims on object counter. Note that the thread will not relinquish synchronization claims  on other objects, e.g.,
synchronized (obj1){
synchronized(obj2) {
..........
obj2.wait();
.........
}
}
obj2.wait() releases synchronization claim on obj2, but not on obj1.
• The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object.  For example, thread th1 of class IncThread notifies thread th2 of class DecThread that it can proceed, th2 will not proceed unless th1 relinquishes all synchronization claims on object counter.
• The awakened  thread will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.  In example 1, thread th1 of class IncThread notifies threads th2 and th4 of class DecThread that they can proceed, thread th2 is not guaranteed to be the next thread to lock object counter. The next thread It can be th1, th2, or th4.