信号量 --- sem_lock

信号量是一种用于实现进程或线程同步和互斥的机制。sem_lock是一个函数名，它可能是一个用于获取信号量的函数。当一个进程或线程需要访问共享资源时，它会调用sem_lock函数来获取信号量。如果信号量的值为0，则表示资源正在被其他进程或线程占用，此时调用sem_lock函数的进程或线程将被阻塞，直到其他进程或线程释放了该资源并增加了信号量的值。如果信号量的值大于0，则表示资源可用，sem_lock函数将减少信号量的值并允许进程或线程访问该资源。

相关问题

#include <stdio.h> #include <pthread.h> #include <semaphore.h> #include <stdlib.h> #include <string.h> #define BUFFER_SIZE 200 char* buffer;//缓冲区 sem_t empty_sem;//空缓冲区信号量 sem_t full_sem;//满缓冲区信号量 pthread_mutex_t mutex;//互斥信号量 void *producer(void *arg) { // 等待空缓冲区 sem_wait(&empty_sem); pthread_mutex_lock(&mutex); // 将产品放入缓冲区 printf("input sonething to buffer:"); fgets(buffer,BUFFER_SIZE,stdin); pthread_mutex_unlock(&mutex); sem_post(&full_sem); pthread_exit(NULL); } void *consumer(void *arg) { // 等待满缓冲区 sem_wait(&full_sem); pthread_mutex_lock(&mutex); // 从缓冲区取出产品 printf("read product from buffer:%s", buffer); memset(buffer,0,BUFFER_SIZE); pthread_mutex_unlock(&mutex); sem_post(&empty_sem); pthread_exit(NULL); } int main(){ pthread_t tid1,tid2; buffer=(char*)malloc(BUFFER_SIZE); //初始化信号量和互斥信号量 sem_init(&empty_sem,0,BUFFER_SIZE);//初始化empty_sem的值为BUFFER_SIZE sem_init(&full_sem,0,0); pthread_mutex_init(&mutex,NULL); //创建生产者和消费者线程 pthread_create(&tid1,NULL,producer,NULL); pthread_create(&tid2,NULL,consumer,NULL); //等待线程结束 pthread_join(tid1,NULL); pthread_join(tid2,NULL); //销毁信号量和互斥信号量 sem_destroy(&empty_sem); sem_destroy(&full_sem); pthread_mutex_destroy(&mutex); printf("The End!\n"); return 0; }

这是一个生产者-消费者问题的代码实现，其中使用互斥量和信号量来实现线程同步和互斥。生产者线程等待空缓冲区信号量，然后获取互斥信号量，将产品放入缓冲区，释放互斥信号量，然后发出满缓冲区信号量。消费者线程等待满缓冲区信号量，然后获取互斥信号量，从缓冲区取出产品，释放互斥信号量，然后发出空缓冲区信号量。主函数中创建生产者和消费者线程，并等待它们结束。在程序结束时，销毁互斥量和信号量。

利用信号量 实现 生产者-消费者问题。

生产者-消费者问题是指一个共享的缓冲区间，生产者将对象放入该缓冲区间，消费者则将对象从缓冲区间取出。但是生产者和消费者不能同时对缓冲区间进行操作，也就是说缓冲区间需要实现互斥访问。而信号量可以用来控制对缓冲区间的访问，实现互斥。

具体地，在实现过程中需要定义两个信号量，一个表示缓冲区间已有的对象数目，另一个表示缓冲区间空的对象数目。生产者在向缓冲区放置对象时，需要先使用空对象信号量进行等待，直到缓冲区间还存在空对象，然后使用已有对象信号量进行加锁，放入对象，释放已有对象信号量。消费者在从缓冲区取出对象时，需要先使用已有对象信号量进行等待，直到缓冲区间有可用的对象，然后使用空对象信号量进行加锁，取出对象，释放空对象信号量。

下面给出一个简单的代码实现：

#include <pthread.h>
#include <semaphore.h>

#define MAX_ITEM 10
#define BUFFER_SIZE (MAX_ITEM + 1)

int buffer[BUFFER_SIZE];
int in, out;
sem_t empty, full, mutex;

void *producer(void *arg)
{
    int item;
    while (1) {
        /* produce an item */
        item = ...

        /* wait for an empty slot */
        sem_wait(&empty);

        /* lock the buffer */
        sem_wait(&mutex);

        /* insert the item into the buffer */
        buffer[in] = item;
        in = (in + 1) % BUFFER_SIZE;

        /* unlock the buffer */
        sem_post(&mutex);

        /* signal a full slot */
        sem_post(&full);
    }
}

void *consumer(void *arg)
{
    int item;
    while (1) {
        /* wait for a full slot */
        sem_wait(&full);

        /* lock the buffer */
        sem_wait(&mutex);

        /* remove an item from the buffer */
        item = buffer[out];
        out = (out + 1) % BUFFER_SIZE;

        /* unlock the buffer */
        sem_post(&mutex);

        /* signal an empty slot */
        sem_post(&empty);

        /* consume the item */
        ...
    }
}

int main()
{
    pthread_t tid1, tid2;

    /* initialize the buffer */
    in = out = 0;

    /* initialize the semaphores */
    sem_init(&empty, 0, BUFFER_SIZE - 1);
    sem_init(&full, 0, 0);
    sem_init(&mutex, 0, 1);

    /* create the producer and consumer threads */
    pthread_create(&tid1, NULL, producer, NULL);
    pthread_create(&tid2, NULL, consumer, NULL);

    /* wait for the threads to finish */
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    /* destroy the semaphores */
    sem_destroy(&empty);
    sem_destroy(&full);
    sem_destroy(&mutex);

    return 0;
}