Simple multithreading java

Question

I've got a inner class in my class doing some asynchronous processing and setting value on parent class. Ex :

class Myclass{
   String test;

   public getTestValueFromMyClass(){
      //this starts asynchronous processing on my inner class
   }

   //inner class
   class InnerClass extends TimerTask{
      //doing something asynchronously, when this process is done
      test = "somevalue";
   }
}

Now here is the problem from Runner class :

class Runner{
    public static void main(String[] args){
       Myclass instance = new Myclass();

       //This is always null because runner class doesn't wait for Inner class to
       //complete asynchronous processing and to set test value
       System.out.println(instance.getTestValueFromMyClass());
    }
}

How do I get around this?

Since you don't appear to be doing anything concurrently, I would use just one thread. If you want to wait for asynchronous tasks I suggest you use an ExecutorService and Future.get(). — Peter Lawrey
– Peter Lawrey, Commented Sep 25, 2012 at 12:45
yes I was intending to wait for asynchronous task to complete and then to print out the result, but I don't know how — Gandalf StormCrow
– Gandalf StormCrow, Commented Sep 25, 2012 at 12:49
i would suggest reading one of the thousands of online tutorials on multi-threading in java. the oracle one is always a good place to start. google will find you many more... — jtahlborn
– jtahlborn, Commented Sep 25, 2012 at 12:54
FYI dude, I forgot to threadPool.shutdown(); the pool in my example. Just edited it. — Gray
– Gray, Commented Sep 26, 2012 at 17:27

Gray · Accepted Answer · 2012-09-26 17:26:29Z

2

Others have suggested similar ideas but I'd use a single thread pool with a Callable.

Your class that is doing the asynchronous processing should implement Callable which will return the computed value. In this example it returns a String but it could also return your own object with more information.

public class MyClass implements Callable<String> {
   public String call() {
      //doing something asynchronously, when this process is done
      return "somevalue";
   }
}

Your Runner class would then create a thread pool, fire off the asynchronous task in the background, and then later wait for it to finish. When you submit a Callable job to the thread-pool, you get a Future class back which can be used to wait for the asynchronous job to finish and to get its return value.

public class Runner{
    public static void main(String[] args) {
       // you can use newFixedThreadPool(...) if you need to submit multiple
       ExecutorService threadPool = Executors.newSingleThreadExecutor();
       // you could store this future in a collection if you have multiple
       Future<String> future = threadPool.submit(new MyClass());
       // after submitting the final job, we _must_ shutdown the pool
       threadPool.shutdown();

       // do other stuff in the "foreground" while MyClass runs in the background

       // wait for the background task to complete and gets its return value
       // this can throw an exception if the call() method threw
       String value = future.get();
       System.out.println(value);
    }
}

edited Sep 26, 2012 at 17:26

answered Sep 25, 2012 at 19:44

Gray

117k24 gold badges305 silver badges360 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

AJW Over a year ago

I have a similar use case, trying to convert AsyncTasks to ExecutorService to return a List from a Room database. Another answer suggests using submit() on ExecutorService and get() on the Dao method (see stackoverflow.com/questions/52242933/room-database-query). Would appreciate your thoughts on that approach versus the approach using a Callable and a Future.

Alexei Kaigorodov · Accepted Answer · 2012-09-25 12:54:43Z

2

Evidently, you have to make getTestValueFromMyClass to wait for InnerClass execution. This can be done with some synchronization facility (Semaphore, CountdownLatch, BlockingQueue...). But most straightforward is to use java.util.concurrent.ScheduledThreadPoolExecutor instead of java.util.Timer. Its method schedule(Callable<V> callable, long delay, TimeUnit unit) returns Future, and Future.get() waits for and returns the computed value.

answered Sep 25, 2012 at 12:54

Alexei Kaigorodov

13.6k1 gold badge24 silver badges38 bronze badges

Comments

OldCurmudgeon · Accepted Answer · 2012-09-25 13:07:19Z

One very simple mechanism is to use a BlockingQueue to communicate between your threads. Here I am creating the queue in the thread class but it could just as easily be created in the caller and passed to the thread.

public class Runner {
  static class MyClass implements Runnable {
    // Thread will post to this queue when it completes.
    BlockingQueue q = new ArrayBlockingQueue(1);

    // Call to wait for the post.
    public void waitForFinish() throws InterruptedException {
      // Just take! This will wait until something gets posted.
      q.take();
    }

    @Override
    public void run() {
      try {
        // Just wait ten seconds.
        Thread.sleep(10000);
      } catch (InterruptedException ex) {
        // Just exit when interrupted.
      } finally {
        try {
          // Signal finished.
          q.put("Done");
        } catch (InterruptedException ex) {
          // Just exit when interrupted.
        }
      }
    }
  }

  public static void main(String[] args) throws InterruptedException {
    // Make my instance.
    MyClass instance = new MyClass();
    // Fire it off.
    new Thread(instance).start();
    // Wait for it to finish.
    instance.waitForFinish();
    // All done.
    System.out.println("Finished");
  }
}

Sebastian Breit · Accepted Answer · 2012-09-25 12:44:05Z

0

You could use a handler and post a message when processing is done!

answered Sep 25, 2012 at 12:44

Sebastian Breit

6,1611 gold badge37 silver badges54 bronze badges

2 Comments

Gandalf StormCrow Over a year ago

thank you for your response, do you have example/link, something similar I don't really know what you're talking about

Sebastian Breit Over a year ago

sorry, my suggestion was intended for Android developing.You don't need a thread for this. But if you insist in having a separate thread, then just call a method when you are ready with processing!

stemm · Accepted Answer · 2012-09-25 13:10:53Z

0

class Myclass{
   // pre initialize thread pool
   private static ExecutorService executor = Executors.newFixedThreadPool( 5 );

   private String test;

   public String getTestValueFromMyClass() throws Exception {
      // start asynchronous calculations
      Future<String> resultHandler = 
           executor.submit( new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                        return "Asynchronously calculated result";
                    }
                } );
      // do something in current thread
      // ...
      // wait until asynchronous task ends, get result 
      // and assign it to instance variable
      this.test = resultHandler.get();

      return test; // returns string "Asynchronously calculated result"
   }
}

edited Sep 25, 2012 at 13:10

answered Sep 25, 2012 at 12:54

stemm

6,0702 gold badges36 silver badges65 bronze badges

2 Comments

Gandalf StormCrow Over a year ago

this returns string Asynchronously calculated result, but my program is still running, why doesn't it end ?

stemm Over a year ago

Because resultHandler.get() waits if necessary for the computation to complete, and then retrieves result (also there is version of get with timeout): docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/…

Collectives™ on Stack Overflow

Simple multithreading java

5 Answers 5

1 Comment

Comments

Comments

2 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

1 Comment

Comments

Comments

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related