Semaphore of thread synchronization

1  Basic concepts

• Simply put, it is an evolutionary version of mutual exclusion （1~N） Counter
• Record the number of resources currently available , Current resource quantity <=0 It's going to block up when it's time , Current resource quantity > Start the operation only when , In addition, semaphore operations are all atomic operations .

Due to the large granularity of mutex , If we want to share some data of an object among multiple threads , There is no way to use mutexes , Only the entire data object can be locked . In this way, the purpose of ensuring the correctness of data when multi-threaded operation shares data is achieved , But it virtually leads to the decrease of thread concurrency . Threads execute from parallel , It becomes serial execution . It's no different from using a single process directly . Semaphore , It's a relative compromise , It can ensure synchronization , The data is not chaotic , It can also improve thread concurrency .

2  Function USES

2.1 sem_init function

effect ： Initialize a semaphore

int sem_init(sem_t *sem, int pshared, unsigned int value);
//  ginseng  1：sem  Semaphore 
//  ginseng  2：pshared  take  0  Used between threads ; Take the  0（ It's usually  1） Used between processes 
//  ginseng  3：value  Specifies the initial value of the semaphore 

The initial value of the semaphore , Determines which threads occupy semaphores （ process ） The number of .

2.2 sem_destroy function

effect ： Destroy a semaphore

int sem_destroy (sem_t *sem);

2.3 sem_wait function

effect ： Lock the semaphore --

int sem_wait(sem_t *sem);

2.4 sem_post function

effect ： Unlock the semaphore ++

int sem_post(sem_t *sem);

2.5 sem_trywait function

effect ： Try to lock the semaphore – ( And sem_wait The difference between lock and trylock)

int sem_trywait(sem_t *sem);

2.6 sem_timedwait function

effect ： Try to lock the semaphore for a limited time --

int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
//  ginseng  2：abs_timeout  Absolute time is used .

3  Semaphores are implemented by producers and consumers

According to the notes , The code is easy to understand . Two semaphores to control , One starts with 0, Indicates that the initial production quantity is 0. Another initial quantity is the number of spaces where goods can be stored , Initialization is the number of cells N.
Mutually exclusive and conditional variables are the way I consume You can't produce . And two semaphores are produced by you I can spend . After all, circular does not affect , At most you produced , I don't know . Afraid of multiple producers , You put it in the grid and I put it again before moving to the next grid .

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>


#define NUM 5

int queue[NUM];                       //  The global array simulation implements the ring queue 
sem_t black_number, product_number;   //  Empty lattice semaphore . Product semaphore 


//  Producer callback function 
void* producer(void* arg) {
    int i = 0;
    int res = 0;

    while (1) {
        //  Lock the empty cell semaphore , Subtract one from the number of spaces , by 0 Then block and wait 
        res = sem_wait(&black_number);
        if (res != 0) {
            fprintf(stderr, "sem_wait black_number error:%s\n", strerror(res));
            exit(1);
        }

        //  Simulate the production of a product 
        queue[i] = rand() % 1000 + 1;
        printf("------Produce---%d\n", queue[i]);

        //  Product semaphore unlock , Put the product ++
        res = sem_post(&product_number);
        if (res != 0) {
            fprintf(stderr, "sem_post product_number error:%s\n", strerror(res));
            exit(1);
        }

        i = (i + 1) % NUM;
        sleep(rand() % 2);
    }
}


//  Consumer callback function 
void* consumer(void* arg) {
    int i = 0;
    int res = 0;

    while (1) {
        //  Consumers will increase the number of products --, by 0 Then block and wait 
        res = sem_wait(&product_number);
        if (res != 0) {
            fprintf(stderr, "sem_wait product_number error:%s\n", strerror(res));
            exit(1);
        }

        printf("==============================Consumer=========%d\n", queue[i]);

        //  Consume a product 
        queue[i] = 0;

        //  After consumption, add the number of spaces ++
        res = sem_post(&black_number);
        if (res != 0) {
            fprintf(stderr, "sem_post black_number error:%s\n", strerror(res));
            exit(1);
        }

        //  Simulate a circular queue 
        i = (i + 1) % NUM;
        sleep(rand() % 5);
    }
}


int main(int argc, char** argv) {
    //  Producer thread and consumer thread 
    pthread_t pid, cid;

    //  Initialize empty lattice semaphore , The semaphore is 5, Sharing between threads ----0
    int res = sem_init(&black_number, 0, NUM);
    if (res != 0) {
        fprintf(stderr, "sem_init black_number error:%s\n", strerror(res));
        exit(1);
    }

    //  Initialize the product semaphore , The number of products is 0
    res = sem_init(&product_number, 0, 0);
    if (res != 0) {
        fprintf(stderr, "sem_init product_number error:%s\n", strerror(res));
        exit(1);
    }


    //  Create a producer thread 
    res = pthread_create(&pid, NULL, producer, NULL);
    if (res != 0) {
        fprintf(stderr, "pthread_create producer error:%s\n", strerror(res));
        exit(1);
    }

    //  Create consumer thread 
    res = pthread_create(&cid, NULL, consumer, NULL);
    if (res != 0) {
        fprintf(stderr, "pthread_create consumer error:%s\n", strerror(res));
        exit(1);
    }

    //  Recycle thread 
    res = pthread_join(pid, NULL);
    if (res != 0) {
        fprintf(stderr, "pthread_join producer error:%s\n", strerror(res));
        exit(1);
    }
    res = pthread_join(cid, NULL);
    if (res != 0) {
        fprintf(stderr, "pthread_join consumer error:%s\n", strerror(res));
        exit(1);
    }

    //  Destroy semaphore 
    res = sem_destroy(&black_number);
    if (res != 0) {
        fprintf(stderr, "sem_destroy black_number error:%s\n", strerror(res));
        exit(1);
    }

    res = sem_destroy(&product_number);
    if (res != 0) {
        fprintf(stderr, "sem_destroy product_number error:%s\n", strerror(res));
        exit(1);
    }

    return 0;
}

perform