Question

I have a loop which need to be turned off so that it can continue to next statements with some values else it crash. What is the best way to do so? For example:

if (data.startsWith("tcp") ) 
{
   /* main.strings should have a value but it may take a while */
   main.start("i generate some encoding/decoding, i take uncertain time...");

   int i = 0;
   while(main.strings != null) 
   {
     /* Maximum 20 time waiting is accepted, else not */
     if (i > 20 ) break; 
     Thread.sleep(1000);
     i++;
   }

   /* It crash, if main.start() is not creating the main.strings  
    * so there is a uncertain specific time, for this but we however can't wait long
    */
   main.NowUDPSend(main.strings); 
   ...
}

Is this the best way to handle the realtime while loop, so that i can exit exactly after 20 times limit over to the next.

Answer 1

for (int i = 0; main.strings != null && i <= 20; ++i) {
  Thread.sleep(1000);
}

will do it, but I would really look into using main.wait(20000) and have the thing that sets main.strings do main.notifyAll() afterwards.

See http://download.oracle.com/javase/tutorial/essential/concurrency/guardmeth.html for a good tutorial.

Threads often have to coordinate their actions. The most common coordination idiom is the guarded block. Such a block begins by polling a condition that must be true before the block can proceed. There are a number of steps to follow in order to do this correctly.

Suppose, for example guardedJoy is a method that must not proceed until a shared variable joy has been set by another thread. Such a method could, in theory, simply loop until the condition is satisfied, but that loop is wasteful, since it executes continuously while waiting.

public void guardedJoy() {
  //Simple loop guard. Wastes processor time. Don't do this!
  while(!joy) {}
  System.out.println("Joy has been achieved!");
}

A more efficient guard invokes Object.wait to suspend the current thread. The invocation of wait does not return until another thread has issued a notification that some special event may have occurred — though not necessarily the event this thread is waiting for:

public synchronized guardedJoy() {
    //This guard only loops once for each special event, which may not
    //be the event we're waiting for.
    while(!joy) {
        try {
            wait();
        } catch (InterruptedException e) {}
    }
    System.out.println("Joy and efficiency have been achieved!");
}

…

When wait is invoked, the thread releases the lock and suspends execution. At some future time, another thread will acquire the same lock and invoke Object.notifyAll, informing all threads waiting on that lock that something important has happened:

public synchronized notifyJoy() {
    joy = true;
    notifyAll();
}