So simulieren Sie Ad-hoc-Netzwerkknoten?

Question

Ich habe Klassen Source, Intermediate und Destination. Die Quellklasse hat eine Methode, die mit einiger Wahrscheinlichkeit neue zu sendende Pakete empfängt. Wann immer ein Paket empfangen wird, sollte es an alle benachbarten Zwischenknoten gesendet werden (simuliert durch eine setPacket-Methode). Zwischenknoten sollten diese Pakete an ihre Nachbarn senden, bis Pakete ihr Ziel erreichen. Das Problem liegt immer dann vor, wenn die Kette der Paketübertragung gestartet wird. Der Quellknoten beendet die Ausführung seiner Methode zum Abrufen neuer Pakete. Im Grunde ist die Quellklasse eingefroren, während die Funktionskette funktioniert. Gibt es eine Möglichkeit, diese beiden Prozesse gleichzeitig auszuführen? (Es ist wie Source-Knoten Anfrage an Zwischenklasse senden und dass man es tun wird, arbeitet unabhängig) Ich habe versucht, für jede der drei Klassen Thread-Klasse zu erweitern, aber immer noch Getriebe-Kette ist einfrieren Source-Klasse. Die verwendete Sprache ist Java, aber wenn es eine andere Sprache gibt, die den Job erledigen kann, kann ich zu ihnen wechseln.

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"); 
    } 
} 

Und das Beispiel Ausgang ist

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 

Allerdings habe ich es smth wie

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

Die Sache ist, dass der ganze Botschaftsübergang im Hauptthread sein will erfolgt. ... müssen Sie die Funktionen createNewSetupMessage und onNewMessageSetup als Instanzen von Runnable implementieren und neue Threads initiieren, um sie auszuführen.

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; 
    } 
} 

dann

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

Seien Sie vorsichtig wenn am Knoten Zuhörer onNewMessageSetup, weil es ein bisschen syncronization abhängig von der Topologie benötigen (zB wenn ein Zwischenknoten ist Listener für mehr als einen unterschiedlichen Knoten) machen, so dass es

@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(); 
    } 

Obwohl die zwei Methoden, um die gleiche Funktionalität bieten und man kann sich an Ihrer Basisklasseimplementierenals eine einzige Methode.