C: Comment faire des threads de communiquer les uns avec les autres?

Intéressant de noter que cela semble être une question de base, et pourtant je ne pouvais pas trouver n'importe quel exemple pour le langage C (dans l'affirmative, je n'ai trouvé que pour Python, C# et C++).

Le point est: Qt programmeur, quand j'ai besoin de faire quelques données transmises entre les différents threads, je commence un signal-slot de connexion entre alors et l'utilisation de la emit signal mécanisme pour faire le travail.

Mais maintenant, je travaille dans une application C pour Linux Embarqué où je dois faire un travail similaire, mais je n'ai pas de Qt mécanisme disponible. La question est: comment puis-je faire deux ou plus de fils de communiquer les uns avec les autres dans C dans une manière similaire à celle de l'intervalle Qt avec les signaux et les slots?

Je sais que l'une des façons de partager des données avec des variables globales avec les changements protégée par un mutex. Mais même alors, je serais probablement incapable de faire le système de manière asynchrone: je voudrais avoir une boucle qui n'auront de cesse de vérifier si la variable a changé ou pas. Mais que faire si je veux exécuter une méthode spécifique d'un fil juste après un autre terminé un travail (et donc, de manière asynchrone)? Il semble alors telle façon échoue.

Remarque: bien que j'utilise Linux Embarqué et, par conséquent, de mentionner certaines options qui permettraient de prendre les fonctions POSIX et autres "liées à Linux moyens" serait utile, ce serait encore mieux pour la communauté si plus de temps est consacré à des solutions qui ne sont pas strictement à une plate-forme spécifique (si c'est possible).

Quelles sont les spécifications de votre système embarqué? Peut-être que vous pourriez utiliser C++?
en fait, je voulais utiliser Qt (C++) dans ce projet (parfaitement viable) si je pouvais utiliser les signaux et les slots et l'aimez, mais le reste de l'équipe a refusé et a préféré continuer à utiliser pur C =T
Je peux sentir votre douleur 🙁

OriginalL'auteur Momergil | 2014-09-16

  1. 7

    Lire un bon tutoriel sur les pthreads. Vous voulez en savoir plus sur les variables de condition pour être utilisé avec mutex.

    variables de Condition, et les mutex doit probablement être suffisant pour vos besoins.

    Vous pouvez également utiliser la plupart des traditionnels communication inter-processus mécanismes entre les threads, par exemple, un pipe(7) (probablement avec poll(2)...). Afin de lire Advanced Linux Programmation et étude syscalls(2) et pthreads(7)

    Éviter d'utiliser signal(7)-s entre les threads.

    Ne sais pas comment syscalls s'inscrit dans cette, mais sinon +1.
    Ils résumer les choses de la CIB (qui peut être utilisé entre les threads): pipe, socket, eventfd etc etc etc ... je ne veux pas faire la liste de tous les syscalls pertinente de la CIB!
    Ouais, mais à mon humble avis c'est surtout intéressant pour un développeur avancé. Je pense que pour un débutant, concentrons-nous sur les bases (comme le mutex, sémaphores et comment les utiliser avec pthreads; la façon dont ils sont utilisés pour coordonner l'accès aux données partagées, etc.).
    Et dans 20 ans, j'ai jamais vu quelqu'un utiliser, ou même parler sur l'utilisation de signaux de communication inter-thread?!
    Quelques questions sur l'mentionnées, mais je ne recommande pas d'utiliser des signaux pour la communication inter-thread.

    OriginalL'auteur Basile Starynkevitch

  2. 3

    Une façon est d'utiliser la transmission de messages entre les threads via asynchrone des files d'attente. De cette façon, vous pouvez éviter d'utiliser des données partagées entre les threads et seulement les files d'attente doivent être thread-safe.

    Asynchrone files d'attente peuvent être mis en œuvre à l'aide de différentes primitives de synchronisation:

    • Des tuyaux ou des sockets.
    • Files d'attente protégée par un mutex et une variable de condition.
    • Non-blocage ou de verrouillage sans files d'attente.
    Python a une couche d'abstraction pour cela.
    Si seulement Python n'ont pas l'infâme GIL...
    Ah oui, l'inter-processus de files d'attente sont un peu plus utile en Python. Aussi je vois la question exclut explicitement Python, je n'ai pas réussi à voir à l'origine.

    OriginalL'auteur Maxim Egorushkin

  3. 1

    Fil auquel vous souhaitez vous informer d'un événement comme "données disponibles", peut enregistrer une fonction de rappel qui peut être trigerred par le déclarant fil. Vous pouvez utiliser un pointeur de fonction pour cela.

    Ex: le Thread 2 enregistre une fonction de callback pour un ou plusieurs événements. Thread 1, lors de l'événement de la condition ou de l'événement appelle la fonction enregistré.

    Mais ce n'est pas résoudre tous les problèmes de synchronisation!
    Original question est "Comment partager des données avec un autre thread dans un asynchrone en mode sans interrogation sur une variable globale". Donc, pour ce faire, vous pouvez utiliser les fonctions de rappel qui est une pratique courante dans de nombreuses bibliothèques.
    Inscrire une fonction de rappel avec quoi, s'il vous plaît? Qui de l'API?
    Vous avez à faire votre propre API pour ce faire. Il n'en est rien, mais un pointeur de fonction.
    Attendez, est-il donc une API, ou tout simplement un pointeur de fonction? Comment est-ce "thread-safe"?

    OriginalL'auteur TSP

  4. 0

    producteur et consommateur de threads doit capturer des uns et des autres tid. producteur sur la production d'envoyer:
    pthread_kill(consumerID, SIGUSR1);
    la consommation est le programme d'installation avec le gestionnaire de signal pour le signal SIGUSR1, et qui peut récupérer le produit de résultat à partir de la commune std::queue sauvé par pthread_setspecific().
    les producteurs et les consommateurs peuvent continuer leurs tâches sans être verrouillé par un sémaphore ou cond var/mutex.

    OriginalL'auteur user10467428