子线程如何向Java中的主线程（方法）发送连续消息？答案

【问题标题】：How can a child thread send continuous messages to main thread(method) in Java?子线程如何向Java中的主线程（方法）发送连续消息？
【发布时间】：2020-10-04 05:54:06
【问题描述】：

我有一个想要相互交流的人的HashMap如下：

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

在这里，密钥中的每个人都有自己的线程，他们将在其中向列表中的每个人发送消息并接收响应。

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

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Master m = new Master();
        m.readFile();
        ExecutorService executorService = Executors.newFixedThreadPool(6);
        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) ));
        }

        while(executorService.awaitTermination(1, TimeUnit.SECONDS));
        for(Future<String> returnFuture: returnFutures){
            System.out.println(returnFuture.get());
        }
        executorService.shutdown();
    }
}

Master 类将迭代地为 HashMap 中的每个键创建一个线程。请注意readFile 方法只会从文本文件中读取并生成我上面提到的输入（到callsMap 变量中）。这对于这个上下文不是特别重要，所以我在这里省略了它。

我有一个SubTasks 类，它实现了Callable 接口并为每次交互创建消息。这个类不会创建任何额外的线程，只是对它收到的调用者和接收者列表进行操作，如下所示：

import java.util.List;
import java.util.concurrent.Callable;

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

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

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

如果我直接在子线程中打印，我会得到想要的结果，因为消息是按随机顺序打印的：

rooney received intro message from zidane [1592165414388]
ronaldo received intro message from scholes [1592165414388]
scholes received intro message from rooney [1592165414388]
rooney received intro message from ronaldo [1592165414389]
zidane received intro message from messi [1592165414389]
scholes received reply message from ronaldo [1592165414434]
zidane received reply message from rooney [1592165414434]
...
...

但我希望将这些消息打印在主方法而不是子线程中。我尝试通过连接 returnMessage 和 callerMessage 来返回消息，但由于我在每个线程结束时返回，它们似乎是按顺序打印的（每对的调用-回复）如下：

rooney received intro message from zidane [1592165584566]
zidane received reply message from rooney [1592165584614]
rooney received intro message from zidane [1592165584632]
zidane received reply message from rooney [1592165584632]
rooney received intro message from zidane [1592165584632]
zidane received reply message from rooney [1592165584632]
...
...

那么，我的问题是如何在 main 方法中打印每个 callerMessage 和 returnMessage，而不是在创建子线程后立即打印它们？

【问题讨论】：

标签： java multithreading parallel-processing java-threads

【解决方案1】：

这看起来像是生产者-消费者问题的经典示例，您的 SubTasks 是生产者，Master 是单个消费者。它可以使用低级 Java 并发结构以多种不同的方式解决，但最简单的一种可能是使用某种线程安全的中间队列。你可以先看看Producer/Consumer threads using a Queue。

【讨论】：