在多个线程之间同步数据

Question

I'm new to the synchronization topic and I couldn't find clear information anywhere about using wait() , notify() , and notifyAll() methods while trying to access to synchronized object. For exmaple if we have such code:

class X extends Thread {
    int x;

    public void methodX()
    {
       synchronized(this)
       {
           //some operations on x
       }
    }
}

class Y extends Thread {
    public void methodY(X x)
    { 
        int z = x.x;
    }
}

Should we call wait() in methodY() and notify() at the end of methodX() ? Otherwise we will not assign any value to z or the thread will wait without explicitly calling wait() until X unlocks?

Answer 1

So give that you need methodY to wait until methodX has executed, one valid way of doing this is wait and notify or notifyAll . There are of course multiple other ways but that one is valid. Given that you may not even need the synchronized block.

void methodX(){
       // do your work here
       this.notifyAll();
}

void methodY(X x){
     x.wait();
     int x = X.x;
}

You might consider putting the blocking code in a getX method in X but the above will work IF (and this is a BIG IF) you can guarantee that methodY starts before methodX because otherwise methodY will miss the notify call.

All of the above said, I agree with JB Nizet , you might consider a more high-level mechanism such as a Semaphore / Mutex / etc. These ease the complexity. For example if you use a CountDownLatch and create it with a count of 1 your code will probably be more robust...

Consider:

class X{
    volatile int x;
    final CountDownLatch cdl = new CountDownLatch(1);

    void methodX(){
        // do work here
        cdl.countDown();
    }

    int getX(){
        cdl.await();
        return x;
    }
}

class Y{
    void methodY(X x){
        int z = X.getX();
    }
}

The above will work every time without any ordering risks.