J'essaie d'obtenir le fil A pour communiquer avec le fil B. Je devrais utiliser un message en passant entre les threads pour le faire, mais j'essaie de trouver un code source d'échantillon qui explique le passage de message.
Quelqu'un a-t-il un bon lien avec un exemple de code source (en C) qui explique le passage de message?
3 Réponses :
Un moyen très facile qui est assez rapide sur Linux au moins est d'utiliser des prises TCP ou UDP pour le passage de message entre les filets. Le noyau Linux est assez intelligent et si je me souviens bien, cela contournera la pile de réseau qui le rend assez rapide. Ensuite, vous n'avez pas à vous soucier de verrouiller et de diverses autres questions qui sont essentiellement gérées par le noyau. Devrait être assez bon pour une mission de devoirs.
La liste des ressources TCP / IP de l'URI FAQ, Tutoriels, Guides, Pages Web et Livres sur TCP / IP
Pourquoi le bowvote? Surtout que la réponse acceptée mentionne les sockets comme une solution possible.
Chaque fil dans un processus peut voir toute la mémoire d'autres threads. Si deux threads contiennent un pointeur sur le même emplacement en mémoire, ils peuvent tous deux y accéder.
Voici le code mais non testé. P>
struct MessageQueue
{
std::queue<std::string> msg_queue;
pthread_mutex_t mu_queue;
pthread_cond_t cond;
};
{
// In a reader thread, far, far away...
MessageQueue *mq = <a pointer to the same instance that the main thread has>;
std::string msg = read_a_line_from_irc_or_whatever();
pthread_mutex_lock(&mq->mu_queue);
mq->msg_queue.push(msg);
pthread_mutex_unlock(&mq->mu_queue);
pthread_cond_signal(&mq->cond);
}
{
// Main thread
MessageQueue *mq = <a pointer to the same instance that the main thread has>;
while(1)
{
pthread_mutex_lock(&mq->mu_queue);
if(!mq->msg_queue.empty())
{
std::string s = mq->msg_queue.top();
mq->msg_queue.pop();
pthread_mutex_unlock(&mq->mu_queue);
handle_that_string(s);
}
else
{
pthread_cond_wait(&mq->cond, &mq->mu_queue)
}
}
Bien que les files d'attente de messages soient bien, l'OP a étiqueté la question avec "C" alors ne peut pas utiliser std :: file d'attente .
Bien que de ne pas avoir de lien, il existe de nombreuses façons de la mettre en œuvre.
premier est d'utiliser des prises. Ce n'est pas en fait une méthode que je recommanderais, car cela peut être beaucoup de travail pour le faire fonctionner correctement.
La seconde est liée à la première méthode, et consiste à utiliser quelque chose appelé Tuyaux anonymes.
Une troisième voie, et celui que j'utilise habituellement, est "inspiré" de la manière dont le message qui passe a fonctionné sur l'ancien système d'exploitation AMIGA: utilisez simplement un Queue . Puisque la mémoire est partagée entre les threads, il est facile de passer simplement des pointeurs autour. Utilisez une file d'attente par fil. N'oubliez pas de protéger les files d'attente, avec quelque chose comme un mutex .
La plate-forme que vous utilisez aura probablement d'autres moyens de communication. Faites une recherche Google pour (par exemple) Linux IPC .
@Asshishagarwal OK, puis recherchez Linux IPC :)
C'est des tuyaux / sockets SYSV IPC et UNIX.
Pouvez-vous publier du code et nous aurons un look.
Utilisez une structure de données courante, protégée par une sorte de verrouillage.
Le passage du message pourrait signifier des sémaphores ou des condamns, votre tuteur vous a-t-il donné des indices à ce sujet?
1. Je dois apprendre le message qui passe en premier, alors ne possédez aucun code source. 2. Je suis à peu près sûr que son message passe et je ne suis pas tout à fait sûr de savoir comment cela fonctionne 3. Je pense que c'est une partie de la communication entre les processus, mais il n'y a pas de notes
Quelques exemples avec une file d'attente de message POSIX et SYSV ici Menehune .opt.wfu.edu / kokua / more_sgi / 007-2478-008 / SGI_HTML / ...