Java：wait（）和notify（）混淆

Question

I'm trying to implement a condition that only one thread to access: Let's say it's a bottle of water - I want only 1 person (thread) to be able to have it a time. Everything seems to work smoothly but I can't get the printing to be shown - the one before the call to wait() ; .

public synchronized void getBotttle  {
    while(myCondition) {
      try {
        System.out.println("Printing that is never done?!");
        wait();
      }
      catch (InterruptedException e) {}
    }

    System.out.println("Printing that works");
    myCondition = true;
    notifyAll(); //or notify(), tried both

    try {
      Thread.sleep(time); // 
    }
    catch (InterruptedException e) {}
    System.out.println("Printing again");
    methodToMakeConditionFalse();
   // notifyAll(); even if I put it here its still the same
}

This method is called by the threads and it works as intended - only 1 thread has the "bottle" but the printing isn't there. Any ideas?

Answer 1

Effectively answer is very simple, signature of your getBotttle() method has keyword synchronized which means never and ever two different threads will access this code simultaneously. So, whole block with while(myCondition) { ... } is fruitless.

Secondly, I recommend you to look into java.util.concurrent.* package.

UPD. Seems worth to clarify what's usual usecase for wait/notifyAll is:

public class WaitNotify {

    public static void main(String[] args) throws InterruptedException {
        new WaitNotify().go();
    }

    private void go() throws InterruptedException {
        ResourceProvider provider = new ResourceProvider();
        Consumer c1 = new Consumer("consumer1", provider);
        Consumer c2 = new Consumer("consumer2", provider);
        Consumer c3 = new Consumer("consumer3", provider);
        Consumer[] consumers = new Consumer[] { c1, c2, c3 };

        for (int i = 0; i < consumers.length; i++) {
            provider.grant(consumers[i]);
        }
    }

    public static class ResourceProvider {
        private Resource resource = new Resource();

        public synchronized void grant(Consumer consumer) throws InterruptedException {
            while (resource == null) {
                wait();
            }
            consumer.useResource(resource);
            resource = null;
        }

        public synchronized void putBack(Resource resource) {
            this.resource = resource;
            notifyAll();
        }
    }

    public static class Resource {
        public void doSomething(String consumer) {
            System.out.println("I'm working! " + consumer);
            try {
                Thread.sleep(3L * 1000L);
            } catch (InterruptedException e) { }
        }
    }

    public static class Consumer implements Runnable {
        private String consumer;
        private Resource resource;
        private ResourceProvider provider;

        public Consumer(String consumer, ResourceProvider provider) {
            this.consumer = consumer;
            this.provider = provider;
        }

        public void useResource(Resource r) {
            this.resource = r;
            new Thread(this).start();
        }

        @Override
        public void run() {
            resource.doSomething(consumer);
            provider.putBack(resource);
        }
    }
}

Answer 2

You don't have a complete example, which makes it hard to tell what you're doing wrong; my guess is that your condition flag isn't set appropriately. Here is a complete example which works, it makes sure that only one thread has access to a resource at a time.

public class StuffExample {

    public static void main(String[] args) throws Exception {

        Worker worker = new Worker(new StuffHolder());
        Thread t1 = new Thread(worker); 
        Thread t2 = new Thread(worker); 

        t1.start();
        t2.start();

        Thread.sleep(10000L);
        t1.interrupt();
        t2.interrupt();
    }
}

class Worker implements Runnable {
    private StuffHolder holder;

    public Worker(StuffHolder holder) {
        this.holder = holder;
    }

    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                holder.useStuff();
                Thread.sleep(1000L);
            }
        }
        catch (InterruptedException e) {
        }
    }
}

class StuffHolder {

    private boolean inUse = false;
    private int count = 0;
    public synchronized void useStuff() throws InterruptedException {
        while (inUse) {
            wait();
        }
        inUse = true;
        System.out.println("doing whatever with stuff now, count=" 
            + count + ", thread=" + Thread.currentThread().getName());
        count += 1;
        inUse = false;
        notifyAll();
    }   
}

Output is:

doing whatever with stuff now, count=0, threadid=Thread-0
doing whatever with stuff now, count=1, threadid=Thread-1
doing whatever with stuff now, count=2, threadid=Thread-0
doing whatever with stuff now, count=3, threadid=Thread-1
doing whatever with stuff now, count=4, threadid=Thread-0
doing whatever with stuff now, count=5, threadid=Thread-1
doing whatever with stuff now, count=6, threadid=Thread-0
doing whatever with stuff now, count=7, threadid=Thread-1
doing whatever with stuff now, count=8, threadid=Thread-0
doing whatever with stuff now, count=9, threadid=Thread-1
doing whatever with stuff now, count=10, threadid=Thread-0
doing whatever with stuff now, count=11, threadid=Thread-1
doing whatever with stuff now, count=12, threadid=Thread-0
doing whatever with stuff now, count=13, threadid=Thread-1
doing whatever with stuff now, count=14, threadid=Thread-0
doing whatever with stuff now, count=15, threadid=Thread-1
doing whatever with stuff now, count=16, threadid=Thread-1
doing whatever with stuff now, count=17, threadid=Thread-0
doing whatever with stuff now, count=18, threadid=Thread-1
doing whatever with stuff now, count=19, threadid=Thread-0

See Oracle's tutorial on guarded blocks .

Answer 3

A big thanks to both of you. I will try write everything clear so other people stuck at something similar can work it out.

What I had is 2 Threads (lets say 2 people). They both have to drink water from 1 bottle, so when the bottle is in use the 2nd person has to wait. My code looked roughly like this:

class Bottle{
 private boolean inUse=false;

 public synchronized void getBotttle(String name, int time)  {
    while(inUse) {
      try {
        System.out.println("The bottle is in use. You have to wait");
        wait();
      }
      catch (InterruptedException e) {}
    }

    System.out.println("Person "+name+" is using the bottle");
    inUse = true;
    notify(); //or notifyAll(), tried both

    try {
      Thread.sleep(time); // sleep the Thread with the person that is drinking at the moment for some time in order for him to finish
    }
    catch (InterruptedException e) {}
    System.out.println("The bottle is now free");
    inUse=false;
   // notify(); even if I put it here its still the same
 }
}

I just started using Threads in java so I wasn't sure where the notify() should really go. What is more I didn't understand that notify() releases the lock only after all the block that has the keyword synchronized is executed. In my case that was not what I wanted and as happens when the lock is released the condition for the while method will be false and the printing will not be executed. The fact that the program was waiting properly and as intended made it hard for me to spot this.

And this is what I wanted and what I got working:

class Bottle{
 private boolean inUse=false;

 public void getBotttle(String name, int time)  {
    while(inUse) {
      try {
        System.out.println("The bottle is in use. You have to wait.");
        synchronized(this){
         wait();
        }
      }
      catch (InterruptedException e) {}
    }

    System.out.println("Person "+name+" is using the bottle");
    inUse = true;

    try {
      Thread.sleep(time); // sleep the Thread with the person that is drinking at the moment for some time in order for him to finish
    }
    catch (InterruptedException e) {}
    System.out.println("The bottle is free now.");
    inUse=false;
    synchronized(this){
     notifyAll();
    }
 }
}

Hopefully last edit: This should prevent 2 threads from skipping the while loop and should be the solution I was looking for

class Bottle{
 private boolean inUse=false;

 public synchronized void getBotttle(String name, int time)  {
    while(inUse) {
      try {
        System.out.println("The bottle is in use. You have to wait.");
        wait();
      }
      catch (InterruptedException e) {}
    }

    System.out.println("Person "+name+" is using the bottle");
    inUse = true;
 }

 public synchronized void sleeping(String name, int time)
    try {
      Thread.sleep(time); // sleep the Thread with the person that is drinking at the moment for some time in order for him to finish
    }
    catch (InterruptedException e) {}
    notifyAll();
    System.out.println("The bottle is free now.");
    inUse=false;
 }
}

Edit: Guess not, printing that bottle is in use is not executed agian...