Waiting for an update

What is the best way to wait for an event/update. For example, I am waiting for this data structure to be updated before doing something. Implementing it inside a loop is not the best way since it consumes much CPU time like:

while (true) {
   // keep checking the data structure
   // if data structure is updated
   //    break;
}
// do something here

What's a simple but efficient way to implement something like this in Jav开发者_Python百科a?

---

wait-notifyAll is more efficient way than loop.

Standard idiom for wait():

synchronized (obj) {
    while(condition not hold) 
        obj.wait();
}

But it's primitive way to control threads, you'd better use classes in java.util.concurrent package. Moreover, I will choose Chris Dail's answer if I meet such problem.

---

It really depends on the structure of the rest of your program. I would probably start by looking through java.util.concurrent to see if something in there suits you.

Examples of ways you could do this:

• Futures - If you have some 'work' to be done, you can have a thread pool executor service to perform the work. When you call submit() to do your work, you get a future that you can check or block until the work is completed.

• Queues - If you have one component doing the work and one component doing the waiting, you could have their communication done with queues. Any time one is done with working on the data, it can add to a queue. You could use the LinkedBlockingQueue and poll() for the work to be completed.

• Listeners - Without concurrent at all, you could use the Listener/Observer pattern.

There are lots of different options depending on your application structure.

---

This is a code sample i would do.

In this logic I use join method in threads. This makes sure all the threads are joined before the execution of the main thread continues. I have put TODO for locations u need to add your code

import java.util.ArrayList;
import java.util.List;

public class MultiThread extends Thread{

    public void run() {
        System.out.println("Starting Thread - " + this.getName()+this.getThreadGroup());
        //TODO data structure is updated here
    }

    public static void main(String[] args) {
        List dataStructureList = new ArrayList() ;//TODO need to replace with list of data structure
        //TODO dataStructureList contain list of items
        Thread[] threadArr = new Thread[dataStructureList.size()];
        for (int j = 0; j < threadArr.length; j++) {
            threadArr[j] = new MultiThread();
            threadArr[j].setName("Thread " + j);
            threadArr[j].start();
        }
        try {
            for (int j = 0; j < threadArr.length; j++) {
                threadArr[j].join();
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("All thread finished");
        //TODO do something here

    }
}

---

Assuming that you use multi-threading in an application. To use one object with several threads you should use synchronization. While one thread initializes data structure, other wait for finishing of initialization. This logic is usually implemented using wait/notify methods which can be called on any object.

Working thread(s):

while (initialized) {
  synchronized (object) {
    object.wait();
  }
}

Initialization thread:

synchronized (object) {
  // initialization
  initialized = true;
  object.notifyAll();
}

object is the data structure which should be initialized. The initialized flag used to indicate that the initialization has completed. It is better to use this flag because sometimes wait can be finished without corresponded notify.