CODEWITHSUNDEEP
javamultithreading
User1
User1

Reputation: 41261

Simple Communication with a Java Thread

I'm looking for a very simple way to communicate with a thread in Java. Consider the following example:


boolean pass=false;
Thread simpleThread=new Thread(){
  public void run(){
    x=doStuff();
    if (x==0) pass=true;
  }
}
simpleThread.start();

I just need to know if doStuff() returned a zero or not. Of course, this is not legal in Java, but how do I implement it properly? It appears that I need some sort of Object that can be written by simpleThread and read by the main thread. What is that missing piece?

Upvotes: 1

Views: 1231

Answers (4)

Tim Bender
Tim Bender

Reputation: 20442

An example using an AtomicBoolean:

final AtomicBoolean pass = new AtomicBoolean(false); //making this final means we can access it in the anonymous Thread instance
Thread simpleThread=new Thread(){
  public void run(){
    x=doStuff();
    if (x==0) pass.set(true);
  }
}
simpleThread.start();
...
pass.get(); //of course, this could return false simply because the newly spawned thread has not completed execution yet

Upvotes: 4

Peter Lawrey
Peter Lawrey

Reputation: 533820

To illustrate @Jon's suggestion.

ExecutorService executor = ...

Future<Integer> result = executor.submit(new Callable<Integer>() {
    public Integer call() {
        return doStuff();
    }
});

// later.
Integer x = result.get();
boolean pass = x==0;

Upvotes: 0

Jon Skeet
Jon Skeet

Reputation: 1503290

You may want to use Future<T>. Instead of starting a new thread directly like this, you'd probably use an ExecutorService, and pass it a Callable<T>. That would return a Future<T> for you.

You could then ask the Future<T> at any time (from the original thread) whether it has already finished, or just block until it has finished (optionally with a timeout).

You can do the equivalent manually with a shared variable, but personally I think the Future/Callable approach is cleaner in the case where you're effectively computing a single (possibly complex) value on a different thread. If you need to regularly communicate with the thread (e.g. to give it more work, or see progress) then it's not as appropriate, of course.

Upvotes: 8

Konstantin Komissarchik
Konstantin Komissarchik

Reputation: 29139

You need to have a shared object that the two threads can see. The object must be modifiable. That is, you cannot use primitives or basic object types like String, Integer, Boolean, etc. as they are immutable.

You also need to understand and use thread synchronization.

Here is an example using a list:

List mylist = new ArrayList();

in-thread
{
   synchronized( mylist )
   {
       mylist.add( _something_ );
   }
}

in-another-thread
{
   synchronized( mylist )
   {
       mylist.get( 0 ); // do something with result;
   }
}

Upvotes: 2

Related Questions