Hersteller/Verbraucher mit Semaphor

Question

Ich beginne meine Studien mit syncronized Fäden mit semaphore.
Ich habe gerade einen Test mit binären Semaphor (nur 2 Threads) und es ist alles gut.

Stellen Sie sich ein Lanhouse vor, das 3 Computer (Threads) und einige Clients (Threads) hat. Wenn alle Computer bussy sind, wartet der Client in einem queue mit einem bekannten Limit (z. B. 15 Clients).

Ich kann nicht verstehen, wie Threads miteinander in Beziehung stehen.

Soweit ich weiß, semaphore wird verwendet, um den Zugriff der Threads auf eine bestimmte kritische Region/Speicherbereich/globale Variable zu steuern.

1) Erstellen Sie 1 Semaphor, um die Clients zu steuern, die auf die Computer zugreifen (aber beide sind Threads);

2) Erstellen Sie 1 Semaphor zur Steuerung der Clients in queue;

Aber wie beziehen sich Threads mit Threads? Wie der Semaphor weiß, mit welchen Threads er arbeiten soll.

Ich brauche keine vollständige Antwort dafür. Ich muss nur verstehen, wie die Threads miteinander in Beziehung stehen. Einige helfen, die Situation zu verstehen.

Das ist mein Code so weit und es funktioniert nicht, P kann die Clients nicht steuern, um auf die 3 verfügbaren Computer zuzugreifen.

#include <pthread.h> 
#include <semaphore.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#define ROOM_SIZE 15 

sem_t queue, pc, mutex; 
int room [ROOM_SIZE]; 
int pcsAvaliable = 3, nAvaliable = 0, roomAvaliable = ROOM_SIZE; 
int computers [3]; // 0 -> Empty | 1 -> Ocuppied 

void* Lan(void* arg) 
{ 
    //Enter the lanhouse 
    //Verify if there is a computer avaliable 
    sem_wait(&pc); 

    if(pcsAvaliable > 0) 
    { 
     sem_wait(&mutex); 
     pcsAvaliable--; 
     computers[nAvaliable] = 1;  
     printf("Cliente pegou pc: %d\n", nAvaliable); 
     nAvaliable++; 
     sem_post(&mutex); 

     //Wait for 80~90ms 
     printf("Client liberou pc: %d\n", nAvaliable); 
     computers[nAvaliable] = 0; 
     nAvaliable--; 

     sem_post(&pc); 
    } 
    else 
    { 
     printf("No computer avaliable...\n"); 
     //Check the waiting room for avaliable slot 
     if(roomAvaliable > 0) 
     { 
      roomAvaliable--; 
      printf("Client entered the waiting room."); 
     } 
     else 
      printf("No avaliable space in waiting room..\n"); 
    } 



} 

int main(int argc, char const *argv[]) 
{ 
    int i; 

    if(argc > 1) 
    { 
     int numClients = atoi(argv[1]); 
     sem_init(&pc, 0, 3); 
     sem_init(&mutex, 0, 1); 
     pthread_t clients[numClients]; 

     //Create Clients 
     for(i=0; i< numClients; i++) 
     { 
      pthread_create(&clients[i], NULL, Lan, NULL); 
     } 

     //Join Clients 
     for(i=0; i< numClients; i++) 
     { 
      pthread_join(clients[i], NULL); 
     } 

    } 
    else 
     printf("Please, insert a parameter."); 
    pthread_exit(NULL); 
    sem_destroy(&pc); 
    return 0; 
} 

Answer 1

Wenn Sie technisch sind, sollten Sie Semaphore verwenden, wenn Sie Aufgaben zwischen Threads synchronisieren. Beispiel zum Lesen der Eingabe vor dem Parsen. Here's eine Antwort auf Semaphoren.

Wenn Sie jedoch gemeinsam genutzte Ressourcen verwenden und Race Condition/zwei Threads gleichzeitig vermeiden möchten, sollten Sie Mutexe verwenden. Here's eine Frage, was ist ein Mutex.

Schauen Sie sich auch die disambiguation von Michael Barr, die wirklich gut ist.

Ich würde beide Fragen gründlich und die Disambiguierung lesen, und Sie könnten am Ende nicht mit Semaphor und nur Mutexe, da von dem, was Sie erklärt, Sie steuern nur eine gemeinsame Ressource.

Gemeinsame Semaphore Funktion

int sem_init(sem_t *sem, int pshared, unsigned int value); //Use pshared with 0, starts the semaphore with a given value 

int sem_wait(sem_t *sem);//decreases the value of a semaphore, if it's in 0 it waits until it's increased 

int sem_post(sem_t *sem);//increases the semaphore by 1 

int sem_getvalue(sem_t *sem, int *valp);// returns in valp the value of the semaphore the returned int is error control 

int sem_destroy(sem_t *sem);//destroys a semaphore created with sim_init 

Gemeinsame Mutexes Funktionen (für Linux nicht sicher, was O. S. Sie laufen) können

int pthread_mutex_init(pthread_mutex_t *p_mutex, const pthread_mutexattr_t *attr); //starts mutex pointed by p_mutex, use attr NULL for simple use 

int pthread_mutex_lock(pthread_mutex_t *p_mutex); //locks the mutex 

int pthread_mutex_unlock(pthread_mutex_t *p_mutex); //unlocks the mutex 

int pthread_mutex_destroy(pthread_mutex_t *p_mutex);//destroys the mutex 

Answer 2

Sie Computer als Mittel behandeln. Die Datenstruktur für die Ressource kann vom Hauptthread initialisiert werden. Dann können Client-Threads versuchen, eine Ressourceninstanz (einen Computer) zu erwerben. Sie können ein Zählsemaphor mit einem Wert 3 für die Anzahl der Computer verwenden.Um einen Computer zu erwerben, ein Client-Thread tut

P (computer_sem). 

ähnlich der Client-Thread freizugeben, zu tun hat,

V (computer_sem) 

Weitere Informationen zu den Themen und Semaphore Verwendung findet POSIX Threads Synchronization in C.