CODEWITHSUNDEEP
java
user1320527
user1320527

Reputation: 25

threads reagarding notification

I was going through threads and I read that ..The notify() method is used to send a signal to one and only one of the threads that are waiting in that same object's waiting pool. The method notifyAll() works in the same way as notify(), only it sends the signal to all of the threads waiting on the object.

Now my query is that if Lets say I have 5 threads waiting and through Notify() , i want to send to notification to thread 3 only, what logic should be there that notification is sent to thread 3 only ..!!

Upvotes: 1

Views: 155

Answers (3)

JiP
JiP

Reputation: 3268

The following code starts up five threads and sets the third one a flag which tells it that it is the only to continue. Then all of the threads that are waiting on the same lock object lock are notified (woken-up), but only the one selected continues. Be careful, writing multi-threaded applications is not easy at all (proper synchronization, handling the spurious wake-ups, etc.) You should not need to wake up only one particular thread from the group as this points to an incorrect problem decomposition. Anyway, here you go...


package test;

public class Main {

  public static void main(String[] args) {
    Main m = new Main();
    m.start(5);
  }

  private void start(int n) {
    MyThread[] threads = new MyThread[n];
    for (int i = 0; i < n; i++) {
      threads[i] = new MyThread();
      /* set the threads as daemon ones, so that JVM could exit while they are still running */
      threads[i].setDaemon(true);
      threads[i].start();
    }
    /* wait for the threads to start */
    try {
      Thread.sleep(500);
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    }
    /* tell only the third thread that it is able to continue */
    threads[2].setCanContinue(true);
    /* wake up all threads waiting on the 'lock', but only one of them is instructed to continue */
    synchronized (lock) {
      lock.notifyAll();
    }
    /* wait some time before exiting, thread two should be able to finish correctly, the others will be discarded with the end of the JVM */
    for (int i = 0; i < n; i++) {
      try {
        threads[i].join(500);
      } catch (InterruptedException ex) {
        ex.printStackTrace();
      }
    }
    System.out.println("Done!");
  }

  /** synchronization object, i.e. a lock which makes sure that only one thread can get into "Critical Section" */
  private final Object lock = new Object();

  /** A simple thread to demonstrate the issue */
  private final class MyThread extends Thread {
    private volatile boolean canContinue;
    @Override
    public void run() {
      System.out.println(Thread.currentThread().getName() + " going to wait...");
      synchronized (lock) {
        while (!canContinue) {
          try {
            lock.wait(1000); /* one second */
          } catch (InterruptedException ex) {
            ex.printStackTrace();
          }
        }
      }
      System.out.println(Thread.currentThread().getName() + " woken up!");
    }
    public void setCanContinue(boolean canContinue) {
      this.canContinue = canContinue;
    }
  };
}

The output of the code is:

Thread-0 going to wait...
Thread-2 going to wait...
Thread-3 going to wait...
Thread-1 going to wait...
Thread-4 going to wait...
Thread-2 woken up!
Done!

So you can clearly see that only the third thread (indexed from zero) is woken up. You have to study the Java synchronization and multi-threading in more detail to understand every particular line of the code (for example, here).

I would like to help you more, but I would have to write almost a book about Java threads and that is why I just pointed out to this Java Tutorial on threads. You are right, this problematics is not easy at all, especially for beginners. So I advise you to read through the referenced tutorial and then you should be able to understand most of the code above. There is no easy way around or at least I do not know of any.

Upvotes: 0

Cratylus
Cratylus

Reputation: 54094

wait-notify is rather a low level mechanism to indicate to other threads that an event (being expected occured). Example of this is producer/consumer mechanism.

It is not a mechanism for threads to communicate to each other.
If you need something like that you are looking in the wrong way.

Upvotes: 2

Taymon
Taymon

Reputation: 25686

You can't directly do this with wait and notify. You'd have to set a flag somewhere, have the code in the thread check it and go back to waiting if it's the wrong thread, and then call notifyAll.

Note that if you have to deal with this, it might be a sign that you should restructure your code. If you need to be able to notify each individual thread, you should probably make each of them wait on a different object.

Upvotes: 4

Related Questions