communication inter-filière java

Question

Je suis nouveau dans le domaine de Java, j'ai fait un peu de programmation en C. Je ne sais pas comment faire. J'essaie de créer un réseau virtuel de nœuds, chaque nœud devant être un thread. Les nœuds ne sont autorisés à parler qu'à leurs voisins. Il y aura un noeud maître qui pourra parler à n'importe quel noeud, mais les noeuds devront se parler entre eux pour revenir au noeud maître.

Au départ, j'allais conserver une liste de nœuds sous forme de tableau, mais j'ai réalisé que tous les nœuds devaient avoir leur propre fil de discussion.

Ma question est la suivante : comment puis-je transmettre des informations entre les threads en Java ? Je dois pouvoir faire en sorte que le nœud maître donne à tous les nœuds réguliers des informations sur leur position. Et j'ai besoin que les noeuds réguliers soient capables de passer des messages à leurs noeuds réguliers voisins ?

Voici mes dépôts git si vous voulez voir le code que j'ai mis en place.

https://github.com/fieldju/cs372_project

en C, j'ai fait un programme qui utilise des tuyaux pour que les enfants parlent entre eux et un serveur qui connecte les clients, mais dans ce problème, les nœuds doivent avoir une communication p2p car la plupart d'entre eux ne peuvent pas communiquer directement avec le nœud maître / serveur.

---

Juste une mise à jour pour tous ceux qui regardent ceci et veulent voir les résultats. J'ai réussi à mettre en place les nœuds et à communiquer avec eux. Vous pouvez consulter le code à l'adresse suivante

https://github.com/fieldju/cs372_project

Je travaille encore sur le vecteur de distance et quelques autres choses, mais à la fin de la semaine prochaine, tout devrait être terminé.

Answer 1

A l'origine, je comptais garder un des nœuds, mais je me suis ensuite réalisé que tous les noeuds devaient être leur propre fil.

Vous pouvez conserver un tableau de fils, il conservera toujours un fil par nœud avec la même structure logique.

comment transmettre l'information en retour entre les threads en Java.

Si les threads résident dans le même processus, les sockets sont définitivement superflus. J'utiliserais un ou plusieurs ConcurrentLinkedQueue pour pousser et envoyer des messages.

Une ou plusieurs dépendent vraiment du type de communication que vous mettez en place. Peut-être une ConcurrentLinkedQueue par nœud, afin que les nœuds envoient des messages aux files d'attente et que chaque nœud sache d'où sortir le message.

Quelques conseils pour la mise en œuvre

Enveloppez toute la logique pour acheminer les messages dans une classe - appelons cette classe VirtualNetwork . VirtualNetwork traite toutes les instances de ConcurrentLinkedQueue et offre une API de méthodes à tous les threads pour envoyer/recevoir des messages. Créez une instance de la classe VirtualNetwork accessible à tous les noeuds - en lui passant une référence dans le constructeur du fil.

C'est une esquisse de comment votre classe NodeThread serait. Remarquez que les classes VirtualNetwork y Message sont des classes que vous devez implémenter vous-même.

class NodeThread extends Thread {

    private int nodeId;
    private VirtualNetwork network;

    public NodeThread(int nodeId,VirtualNetwork network) {
        this.network = network;
        this.nodeId = nodeId;
    }
    public void run() {
        /* when you have to send */
        int nodeReceptor = this.nodeId -1; /* neighbor in the array of threads */
        Message m = new Message(this.nodeId,nodeReceptor);
        m.setContent(10);
        network.send(m);

        /* when you have to receive */
        Message m = network.receive(this.nodeId);
        /* it's your decision to implement this in a blocking way or not */
    }
}

Answer 2

Un moyen simple (mais pas optimal) de commencer est de créer un fichier BlockingQueue pour chaque paire de fils qui doivent transmettre des valeurs dans un sens (si c'est bidirectionnel, il en faut deux fois plus).

Answer 3

Vous pourriez certainement utiliser Douilles . Il existe quelques tutoriels/descriptions aquí y aquí . Votre description du projet suggère qu'une configuration client/serveur fonctionnerait bien puisque vous avez un "nœud maître" central. Le maître sera le serveur et les autres fils pourront se connecter au maître/serveur pour recevoir leurs mises à jour.