java - 如何模拟ad hoc网络节点？

Question

我有源类、中级类和目标类。源类具有以一定概率接收要发送的新数据包的方法。每当收到数据包时，都应该将其广播(通过某种 setPacket 方法模拟)到所有邻居中间节点。中间节点应将这些数据包广播到其邻居，直到数据包到达目的地。问题是每当数据包传输链启动时，源节点就会停止运行其获取新数据包的方法。因此，基本上，当函数链正在工作时，源类被卡住。有什么办法可以同时运行这两个进程吗？ (这就像源节点将向中间类发送请求，并且该节点将独立完成它的工作)我尝试为三个类中的每一个扩展 Thread 类，但传输链仍然卡住源类。使用的语言是Java，但如果有任何其他语言可以完成这项工作，我可以切换到它们。

public class Main {
    public static void main(String[] args) {
        // init nodes
        SourceNode sourceNode = new SourceNode();
        IntermediateNode intermediateNode1 = new IntermediateNode();
        IntermediateNode intermediateNode2 = new IntermediateNode();
        IntermediateNode intermediateNode3 = new IntermediateNode();
        DestinationNode destinationNode = new DestinationNode();

        // create network topology, S - I - I - I - D
        sourceNode.setNextNode(intermediateNode1);
        intermediateNode1.setNextNode(intermediateNode2);
        intermediateNode2.setNextNode(intermediateNode3);
        intermediateNode3.setNextNode(destinationNode);

        // setup listeners
        sourceNode.setSetupMessageListener(intermediateNode1);
        intermediateNode1.setSetupMessageListener(intermediateNode2);
        intermediateNode2.setSetupMessageListener(intermediateNode3);
        intermediateNode3.setSetupMessageListener(destinationNode);

        sourceNode.run();
    }
}

public interface SetupMessageListener {
    void onNewSetupMessage();
}

public class Node {
    protected SetupMessageListener setupMessageListener;
    protected Node nextNode;
    public void setNextNode(Node nextNode) {
        this.nextNode = nextNode;
    }
    public void setSetupMessageListener(SetupMessageListener setupMessageListener) {
        this.setupMessageListener = setupMessageListener;
    }
}

import java.util.Random;

public class SourceNode extends Node implements Runnable {
    @Override
    public void run() {
        while(true) {
            // simulate generating new setup message with probability 1/10
            Random random = new Random();
            int rv = random.nextInt(10);
            if (rv == 0) {
                createNewSetupMessage();
            }
        }
    }
    public void createNewSetupMessage() {
        System.out.println("New setup message was created in Source Node");
        if (setupMessageListener != null) {
            setupMessageListener.onNewSetupMessage();
        }
    }
}

public class IntermediateNode extends Node implements SetupMessageListener {
    public static int count = 0;
    private int id;
    public IntermediateNode() {
        id = count++;
    }
    @Override
    public void onNewSetupMessage() {
        System.out.println("Intermediate Node " + id + " got notified about setup message");
        // pass setup message to next neighbor
        setupMessageListener.onNewSetupMessage();
    }
}

public class DestinationNode extends Node implements SetupMessageListener {
    @Override
    public void onNewSetupMessage() {
        System.out.println("Destination Node got notified about new setup message");
    }
}

示例输出是

New setup message was created in Source Node
Intermediate Node 0 got notified about setup message
Intermediate Node 1 got notified about setup message
Intermediate Node 2 got notified about setup message
Destination Node got notified about new setup message
New setup message was created in Source Node
Intermediate Node 0 got notified about setup message

但是，我希望它像这样

New setup message was created in Source Node
Intermediate Node 0 got notified about setup message
New setup message was created in Source Node
Intermediate Node 1 got notified about setup message
Intermediate Node 0 got notified about setup message
Intermediate Node 2 got notified about setup message
Destination Node got notified about new setup message

Answer 1

问题是整个消息传递都是在主线程中完成的......您需要将 createNewSetupMessage 和 onNewMessageSetup 的功能实现为 的实例>可运行并启动新线程来运行它们。

public class SetupMessageSender implements Runnable{


    private SetupMessageListener setupMessageListener;

    public SetupMessageSender(SetupMessageListener setupMessageListener){
        this.setupMessageListener = setupMessageListener;
    }

    @Override
    public void run() {
        if (setupMessageListener != null) {
            setupMessageListener.onNewSetupMessage();
        }
    }

    public SetupMessageListener getSetupMessageListener() {
        return this.setupMessageListener;
    }

    public void setSetupMessageListener(SetupMessageListener setupMessageListener) {
        this.setupMessageListener = setupMessageListener;
    }
}

然后

    public void createNewSetupMessage() {
                System.out.println("New setup message was created in Source Node");
                Thread smService = new Thread(new SetupMessageSender(this.setupMessageListener));
                smService.start();
            }

但在节点监听器 onNewMessageSetup 处要小心，因为它需要一些 syncronization取决于拓扑(例如，如果一个中间节点是多个不同节点的监听器)，因此将其设置为

@Override
    public synchronized void onNewSetupMessage() {
        System.out.println("Intermediate Node " + id + " got notified about setup message");
        // pass setup message to next neighbor
        Thread smService = new Thread(new SetupMessageSender(this.setupMessageListener));
        smService.start();
    }

尽管这 2 个方法提供相同的功能，但您可以在基类 Node 中将它们作为单个方法实现。