Java中如何将子线程的消息返回到主线程（方法）？

Question

I have a HashMap of people who want to communicate with each other as follows:

{zidane=[rooney, rooney, rooney, scholes, rooney], rooney=[scholes, messi, scholes], scholes=[ronaldo], ronaldo=[rooney, messi, scholes], messi=[zidane]}

Here, each person in the key will have their own threads in which they will send a message to each person in their list and receive a response.

import java.util.*;

public class Master {
    public Map callsMap = new HashMap<String, List>();

    public static void main(String[] args){
        Master m = new Master();
        m.readFile();
        Iterator<Map.Entry<String, List>> it = m.callsMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, List> pair = it.next();
            String caller = pair.getKey();
            List receiverList = pair.getValue();
            SubTasks st = new SubTasks(caller, receiverList);
            Thread thread = new Thread(st);
            thread.start();
            //st.getMessage();
        }
    }
}

The master class will iteratively create a thread for every key in the HashMap. Please note that the readFile method will just read from a text file and produce the input (into callsMap variable) I have mentioned above. It is not particularly important for this context so I have omitted it here.

I have the SubTasks class which extends the Thread class and creates messages for each interaction. This class will not create any additional threads but just operate on the caller and receiver list it received as follows:

import java.util.List;

public class SubTasks extends Thread {
    private String caller;
    private List receiverList;
    private volatile String returnMessage;

    SubTasks(String s, List l){
        caller = s;
        receiverList = l;
    }

    public void setMessage(String msg){
        returnMessage = msg;
    }

    public String getMessage() {
        return returnMessage;
    }

    @Override
    public void run(){
        for (int i = 0; i < receiverList.size(); i++) {
            System.out.println(receiverList.get(i)+" received intro message from "+caller +" ["+System.currentTimeMillis()+"]");
            returnMessage = caller+" received reply message from "+receiverList.get(i) +" ["+System.currentTimeMillis()+"]";
            //setMessage(returnMessage);
            System.out.println(returnMessage);
        }
    }
}

I get the desired output if I print the messages in the child threads for all 26 pairs.

zidane received message from messi [1592117172946]
rooney received message from ronaldo [1592117172946]
scholes received message from rooney [1592117172946]
rooney received message from zidane [1592117172946]
ronaldo received message from scholes [1592117172946]
messi received reply from zidane [1592117172989]
ronaldo received reply from rooney [1592117172989]
...
...

How do I pass these messages into the main thread (method) and print it there instead of the child threads? I tried using getter-setter methods but since the threads will execute randomly, there is no way to call the getter methods properly.

Answer 1

I would suggest to you to use Executor framework Callable interface and Futures in your usecase, since everything you need is already solve. Rewriting the class would help you to solve it properly.

     public class Master {
        public Map callsMap = new HashMap<String, List>();

            public static void main(String[] args){
                Master m = new Master();
                m.readFile();
                ExecutorService executorService = Executors.newFixedThreadPool(10);// or some desired number
                List<Future<String>> returnFutures = new ArrayList<>();
                Iterator<Map.Entry<String, List>> it = m.callsMap.entrySet().iterator();
                while (it.hasNext()) {
                    Map.Entry<String, List> pair = it.next();
                    String caller = pair.getKey();
                    List receiverList = pair.getValue();
                    returnFutures.add(executorService.submit(new SubTasks(caller, receiverList) ));
                }
                executorService.shutdown();
                while(executorService.awaitTermination(1000, TimeUnit.SECONDS));
                for(Future<String> returnFuture: returnFutures){
                     /* returnFuture.get() will have the returned value from the thread, if the thread has completed execution, 
                     otherwise it will wait for the completion*/
                    System.out.println(returnFuture.get());

                }
            }
    }

and

    public  class SubTasks implements Callable<String> {
        private String caller;
        private List receiverList;
        private volatile String returnMessage;

        SubTasks(String s, List l){
            caller = s;
            receiverList = l;
        }

        public void setMessage(String msg){
            returnMessage = msg;
        }

        public String getMessage() {
            return returnMessage;
        }

        @Override
        public String call (){
            for (int i = 0; i < receiverList.size(); i++) {
                System.out.println(receiverList.get(i)+" received intro message from "+caller +" ["+System.currentTimeMillis()+"]");
                returnMessage = caller+" received reply message from "+receiverList.get(i) +" ["+System.currentTimeMillis()+"]";
                return returnMessage;
            }
        }
    }