...

Generally you should call wait in a loop (the thread may be notified  
before you want wait to return).  You should usually call notifyAll rather  
than notify, unless you have a good reason not to.  A thread must own an  
object's monitor to call wait or notify, so you need to synchronize these  
calls (not necessarily the whole method, but you need to make sure the  
flag does not change between the evaluation of the while condition and the  
call to wait).

This should work:

private volatile flag = false;

public synchronized void blockingCall()
{
    while (!flag) // Loop so this method doesn't return before the flag is  
true.
    {
        try
        {
            wait();
        }
        catch (InterruptedException ex)
        {
            // Ignore and loop again until the flag is true.
        }
    }
}

/**
 * Call this from another thread while the above method is blocking
 * to make it return.
 */
public synchronized void unblock()
{
    flag = true;
    notifyAll();
}

Dan.