Utilisation de pthreads sur deux fonctions en C

Question

Je suis complètement nouveau sur pthreads et il semble y avoir beaucoup d'informations inutiles sur tout le site que j'ai regardé.

J'ai deux fonctions appelons les simplement X et Y pour l'instant, elles fonctionnent toutes les deux sur des blocs en mémoire. Si un thread exécute X, je ne veux pas que d'autres threads appellent X ou Y sur le même bloc, comment puis-je m'assurer que cela n'arrivera jamais?

Ai-je besoin de verrouiller mutex les fonctions pour certaines valeurs de bloc?

Answer 1

approche tout ou rien peut-être un code de démonstration est en ordre. En supposant que vous avez un en-tête de bloc comme ceci:

struct block { 
    void *data; 
    size_t len; 
}; 

Vous protégerait le bloc en ajoutant une variable mutex à cette structure:

struct block { 
    void *data; 
    size_t len; 
    pthread_mutex_t lock; 
}; 

Vous devez ensuite mettre à jour la fonction d'initialisation de cette structure pour initialiser la serrure:

struct block *new_block(size_t len) 
{ 
    struct block *b = malloc(sizeof *b); 
    b->data = malloc(len); 
    b->len = len; 

    pthread_mutex_init(&b->lock, NULL); 

    return b; 
} 

X et Y fonctions (et toute autre fonction qui lit ou écrit au bloc) alors besoin de prendre le verrou et relâchez à la sortie:

int x(struct block *b) 
{ 
    int retval; 

    pthread_mutex_lock(&b->lock); 

    /* code */ 

    pthread_mutex_unlock(&b->lock); 
    return retval; 
} 

int y(struct block *b) 
{ 
    int retval; 

    pthread_mutex_lock(&b->lock); 

    /* code */ 

    pthread_mutex_unlock(&b->lock); 
    return retval; 
} 

Vous devez prendre soin de vous assurer que vous déverrouillez le mutex même dans les chemins de retour d'erreur, aussi.

Answer 2

Vous devrez utiliser des mutex.

Vous ne devez pas verrouiller le code, vous devez verrouiller les données. Créez un mutex pour chaque bloc et verrouillez-le pendant qu'une fonction fonctionne sur le bloc, puis déverrouillez-le lorsque vous avez terminé. Un mutex est un type défini par pthread.h, pthread_mutex_t. Des fonctions sont fournies pour verrouiller et déverrouiller le mutex. Ces fonctions garantissent qu'un seul thread peut obtenir un verrou à la fois (si vous venez d'utiliser une variable pour indiquer que votre bloc est utilisé, vous aurez des problèmes de concurrence avec cette variable au lieu du bloc).

De nombreux tutoriels sont disponibles en ligne. Google "tutoriel pthread" et vous devriez trouver assez pour vous lancer.

Answer 3

Vous verrouillez la ressource - dans ce cas, un bloc de mémoire - avec un mutex. Vous pouvez également verrouiller uniquement les parties du code de vos fonctions qui lisent/mettent à jour cette zone de mémoire. C'est ce qu'on appelle une section critique, et nécessite une approcch différente pour le codage. Cela signifie que vos threads sont libres de fonctionner sauf lorsqu'ils touchent la partie où ils interagissent avec la ressource.

La première méthode est plus facile à mettre en œuvre - juste un pour l'ensemble de la fonction X ou Y.

Answer 4

La programmation multi-thread est vraiment mieux résolue en utilisant des langages de plus haut niveau. Certaines choses sont difficiles à comprendre en C et, à mon avis, mutli-threading est l'un d'entre eux. J'ai trouvé que Java m'a donné une meilleure idée des problèmes et des problèmes. Il a plus facile à comprendre les concepts et plus facile à lire la documentation. Un framework C++ tel que Poco ou Qt serait également préférable si Java n'est pas votre truc.

Comme d'autres l'ont dit, conceptuellement vous voulez verrouiller des ressources (dans votre cas une section de mémoire). Les sémaphores, en tant que concept, correspondent beaucoup mieux à ce problème que le mutex.Je voudrais rechercher des sémaphores et juste penser à mutexes comme un bloc de construction de sémaphores. Si vous me demandez, un mutex est un sémaphore binaire mal nommé.