如何使可运行实例在一个线程中等待并由其他线程通知？

Question

in the below code, one runnable instance is waiting to get notify. how to notify this thread by some other thread should i use method or one more class which contains thread to notify.. i am stuck here please help...

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Observable;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.cgi.sample.jms.requestor.RequestorApplication.Runner;

public class RequestorApplication {

    public static String correlationId;

    static ArrayList<Runner> list = new ArrayList<Runner>();

    static Map<Long, Runner> map = new HashMap<Long, Runner>();

    static Runner runner;


    public static void main(String args[]) throws Exception {

        RequestorApplication application = new RequestorApplication();

        application.waiter(map);

        System.out.println("All the threads are started");
    }

    public void waiter(Map<Long, Runner> map) {

        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 2; i++) {

            Runner instance = new Runner();

            System.out.println("Executing thread " + " with " + Thread.currentThread().getName());

            long threadId = Thread.currentThread().getId();

            String threadname = Thread.currentThread().getName();

            executor.execute(instance);

            RequestorApplication.runner = instance;

            synchronized (RequestorApplication.runner) {

                map.put(threadId, RequestorApplication.runner);



                try {
                    RequestorApplication.runner.wait();
                    // notifier(map);
                    System.out.println(threadname + "  Thread entered into waiting state!!!");
                    // Thread.currentThread().wait();
                    System.out.println(threadname + "  Thread woke up from wait!!!!!");

                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }

    }

    public void notifier(Map<Long, Runner> map) {
        synchronized (RequestorApplication.runner) {

            for (Map.Entry<Long, Runner> entry : map.entrySet()) {

                System.out.println("stored threads in map are--->" + map.get(entry.getKey()));

                entry.getValue().notify();
            }

        }

    }

    class Runner implements Runnable {
        public void run() {
            System.out.println("runner invoked");

        }

    }

}

Answer 1

Should i use method or one more class which contains thread to notify?

Don't notify() threads. Notify objects . The "Guarded Blocks" section of the Java Concurrency tutorial explains how wait() and notify() are meant to be used. https://docs.oracle.com/javase/tutorial/essential/concurrency/guardmeth.html

---

Usually, you should avoid wait() and notify() altogether. They are low-level primitive, meant to be used for implementing higher-level synchronization objects. The java.util.concurent package already has quite a few higher-level objects that you can use. That means less work for you to write correct code, and less work for somebody else who needs to understand your code.

Answer 2

in the below code, one runnable instance is waiting to get notify...

You are using an ExecutorService thread-pool but completely missing one of the great features of it. When you add a job to the thread-pool, use the submit(...) method which returns a Future object. You then can call future.get() to wait for the job to complete and return a value. You should never need to do your own waiting, etc..

Future<Void> future = executor.submit(instance);
// now we wait for the thread to complete
future.get();

Also, although it works, it is considered very bad form to call Thread.wait() directly. It happens that a notify() is called when the thread finishes but that is an implementation detail that should be relied on. Either join with a Thread or use the Future.get() above. Also, if the thread returned before you called wait() you might miss the notify() and your code would never return.

Lastly, as @vijayraj34 points out, your code is right now single threaded because you submit each job and then immediately wait for it. What you should be doing is forking all of your threads and saving the Future objects in a collection. Then once you are done starting the jobs you can wait for each Future in turn.

Something like:

List<Future<Void>> futures = new ArrayList<>();
for (int i = 0; i < 2; i++) {
   Runner instance = new Runner();
   // save the futures for later
   futures.add(executor.submit(instance));
}
// after we submit all of our jobs we shutdown the thread-pool
executor.shutdown();
...
// now we go back and wait for all of the runners that have been working in the background
for (Future<Void> future : futures) {
   future.get();
}

Answer 3

@Gray is right but it's best to retrieve futures using a completionService rather than directly so that you can minimize waiting. CompletionService allows you to get the value from a future as future objects become available.