信号量机制解决经典同步互斥问题

已于 2024-01-24 21:07:24 修改
阅读量1.1k 收藏 17
点赞数 32
分类专栏： 操作系统 文章标签： 操作系统 进程同步 C语言 Linux
于 2024-01-24 21:03:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_40395808/article/details/135830547
版权

生产者 / 消费者问题、读者 / 写者问题和哲学家问题是操作系统的三大经典同步互斥问题。本文将介绍这三个问题的基本特点以及如何用信号量机制进行解决。

在分析这三个问题之前，我们首先需要了解用信号量机制解决同步互斥问题的一般规律： 实现同步与互斥的P、V操作都是成对出现，但互斥问题的P、V操作出现在同一个进程中；同步问题的P、V操作出现在不同进程中。

1. 生产者 / 消费者问题

1.1 基本特点

生产者/消费者问题具体表现为：

  1. 两个进程对同一个内存资源进行操作，一个是生产者，一个是消费者。
  2. 生产者往共享内存资源填充数据，如果区域满，则等待消费者消费数据。
  3. 消费者从共享内存资源取数据，如果区域空，则等待生产者填充数据。
  4. 生产者的填充数据行为和消费者的消费数据行为不可在同一时间发生。

1.2 解决思路

首先，我分析了其中存在的同步互斥关系： 生产者-消费者之间的同步关系表现为缓冲区空，则消费者需要等待生产者往里填充数据，缓冲区满则生产者需要等待消费者消费。两者共同完成数据的转移或传送；生产者-消费者之间的互斥关系表现为生产者往缓冲区里填充数据的时候，消费者无法进行消费，需要等待生产者完成工作，反之亦然。

然后，我根据存在的互斥同步关系设置了三个信号量：由于存在互斥关系，我设置了一个互斥信号量mutex控制两者不能同时操作缓冲区；由于存在同步关系，我设置了两个信号量empty和full分别表示缓冲区中的资源数和缓冲区中的空位置数。mutex初值为1，empty初值为0，full初值为缓冲区大小。

最后，进行对生产者和消费者的行为设计：

针对生产者，生产者生产资源，先用P(full)判断缓冲区是否有空，再用P(mutex)判断是否有人在用缓冲区，若缓冲区有空且无人用，则生产者将资源放入缓冲区。放完后，先用V(mutex)释放缓冲区的使用权，再用V(empty)将缓冲区中的资源数加1，生产者进程结束。

针对消费者，消费者先用P(empty)判断缓冲区中是否有资源，再用P(mutex)判断缓冲区是否有人用，若缓冲区有资源且无人用，则消费者从缓冲区中取资源。取完后，先用V(mutex)释放缓冲区的使用权，再用V(full)将缓冲区中的空位置数加1，消费者进程结束。

1.3 代码及运行结果

生产者 / 消费者问题的C语言代码实现如下：

/****************************************************************
 *问题：多个生产者，多个消费者，有限缓冲区
 *描述：
 *1.两个进程对同一个内存资源进行操作，一个是生产者，一个是消费者。
 *2.生产者往共享内存资源填充数据，如果区域满，则等待消费者消费数据。
 *3.消费者从共享内存资源取数据，如果区域空，则等待生产者填充数据。
 *4.生产者的填充数据行为和消费者的消费数据行为不可在同一时间发生。
****************************************************************/
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

#define N 5  //生产者N个，消费者N个
#define BUFFERSIZE 3  //缓冲区大小

sem_t mutex;  //互斥信号量
sem_t empty;  //缓冲区中的资源数
sem_t full;   //缓冲区的空位置数

void *producer(void *arg) {
    int i = *((int *) arg);
    
    //生产者生产资源
    printf("The %dth producer is producing...\n", i);
    sleep(3);

    sem_wait(&full);  //判断缓冲区是否有空
    sem_wait(&mutex); //判断是否有人在用缓冲区

    //若缓冲区有空且无人用，生产者将资源放入缓冲区
    printf("The %dth producer is appending...\n", i);
    sleep(3);

    sem_post(&mutex); //生产者退出缓冲区
    sem_post(&empty); //缓冲区的资源数增加  
}

void *consumer(void *arg) {
    int i = *((int *) arg);

    sem_wait(&empty); //判断缓冲区中是否有资源
    sem_wait(&mutex); //判断是否有人在用缓冲区

    //若缓冲区中有资源且无人用，消费者从缓冲区取资源
    printf("The %dth consumer is taking...\n", i);
    sleep(3);

    sem_post(&mutex); //消费者退出缓冲区
    sem_post(&full);  //缓冲区的空位置数增加

    //消费者消耗资源
    printf("The %dth consumer is consuming...\n", i);
    sleep(3);
}

int main() {
    int i;
    pthread_t proThread[N];
    pthread_t conThread[N];
    int proId[N];
    int conId[N];
    sem_init(&mutex, 0, 1);  //初始化互斥信号量为1
    sem_init(&empty, 0, 0);  //初始化缓冲区中的资源数为0
    sem_init(&full, 0, BUFFERSIZE);  //初始化缓冲区中的空位置等于缓冲区大小
    for (i = 0; i < N; i++) {
        proId[i] = i;
        conId[i] = i;
        pthread_create (&proThread[i], NULL, producer, &proId[i]);//创建生产者线程
        pthread_create (&conThread[i], NULL, consumer, &conId[i]);//创建消费者线程
    }
    for ( i = 0; i < N; i++) {
        pthread_join(proThread[i], NULL);//等待所有的生产者线程执行完毕再结束
        pthread_join(conThread[i], NULL);//等待所有的消费者线程执行完毕再结束
    }
    return 0;
}

运行结果如下图所示：
生产者/消费者问题运行结果

2. 读者 / 写者问题

2.1 基本特点

读者/写者问题具体表现为：

  1. 一个进程在读的时候，其他进程也可以读。
  2. 一个进程在读/写的时候，其他进程不能进行写/读。
  3. 一个进程在写的时候，其他进程不能写。

2.2 解决思路

首先，分析其中存在的同步互斥关系：读者-写者之间没有明显的同步关系，它们不需要合作完成某件事情；读者-写者之间的互斥关系表现为两者不能同时访问文件。

然后，根据存在的互斥关系设置信号量：由于读者-写者的互斥，我设置了一个互斥信号量wsem来控制读者和写者的互斥访问。但如果只设置了这一个信号量，读者和读者之间的互斥也出现了。因为可能会有多个读者，所以我又设置了一个变量readcount记录读者的数量。这时，readcount又需要实现多个读者对它的互斥访问，为此，我设置了一个互斥信号量x。wsem与x的初值均为1，readcount的初值为0，现在所有的信号量已经设置好了。

最后，进行行为设计：读者 / 写者问题有读者优先与写者优先两种解决思路。

2.2.1 读者优先

读者优先的解决思路如下：

针对读进程，首先用P(x)判断是否有人在更新readcount，若无人在改动readcount，则将readcount加1。如果加1后的readcount等于1，则说明加1前的readcount为0，此时的进程为第一个读进程。第一个读进程出现，就要用P(wsem)来限制写进程的访问。然后，用V(x)释放readcount的更新权，读者开始读。读完后，再用P(x)重新获取readcount的更新权，将读进程的数量readcount减1。如果减1后的readcount等于0，则说明所有的读进程都读完了，可以用V(wsem)释放读/写的访问权了。最后，再用V(x)释放readcount的更新权。读进程结束。

针对写进程，首先用P(wsem)获取写的访问权，不让其他读/写进程访问。然后该写进程开始写，写完再用V(wsem)释放读/写的访问权。写进程结束。

2.2.2 写者优先

写者优先与读者优先的很大不同是，如果同时有读写进程在等待，要保证在等待的写进程比在等待的读进程优先执行。为此，设置了信号量z，保证等待的写进程可以跳过它前面等待的读进程。在读者优先的信号量设置基础上，增加了互斥信号量rsem控制写进程想写时，不允许新的读进程来读。增加了整型变量writecount记录等待的写者数，因writecount是共享变量，因此还要设置新的互斥信号量y以实现进程对writecount的互斥访问。

行为设计如下：

针对读进程，首先用P(z)保证写者优先，然后用P(rsem)判断有没有写进程在临界区，有，则等待；没有，则不让新的写进程进入临界区。接下来用P(x)开始对readcount的互斥访问，更新读进程的数量，第一个读进程用P(wsem)判断是否有写进程在进行写操作，有，则需要等待；没有，则不让写进程进行新写操作，用V(x)结束对readcount的互斥访问，用V(rsem)给写进程进入临界区的权利。然后V(z)，可以开始读了。读完后的行为与读者优先时一样。读进程结束。

针对写进程，首先用P(y)开始对writecount的互斥访问，更新写进程的数量，第一个写进程需要判断是否有读进程在临界区，有的话需要等待，没有的话不让新的读进程进来。然后，用V(y)结束对writecount的互斥访问。接着就是写进程的互斥写操作了，同一时刻只有一个写进程可以写，这些行为也与读者优先时一样。在写完后，用P(y)开始对writecount的互斥访问，更新写进程数量。对最后一个离开临界区的写进程，用V(rsem)给读进程可以进临界区的权利，最后用V(y)结束对writecount的互斥访问。写进程结束。

2.3 代码及运行结果

2.3.1 读者优先

读者 / 写者问题（读者优先）的C语言代码实现如下：

/**************************************************************
 *问题：读者/写者问题，读者优先
 *描述：
 *1.一个进程在读的时候，其他进程也可以读。
 *2.一个进程在读/写的时候，其他进程不能进行写/读。
 *3.一个进程在写的时候，其他进程不能写。
 *4.当至少有一个读进程在读时，后来的读进程无须等待，可直接加入。
**************************************************************/
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

#define N 10  //读者N个，写者N个

int readcount;  //记录读进程的数量
sem_t x;     //x控制readcount的互斥访问
sem_t wsem;  //wsem对写互斥控制

void *reader(void *arg) {
    int i = *((int *) arg);

    sem_wait(&x);
    readcount++;
    if (readcount == 1) { //第一个读进程出现，锁住不让写
        sem_wait(&wsem);
    }
    sem_post(&x);
  
    printf("The %dth reader is reading...\n", i);
    sleep(3);
    sem_wait(&x);
    readcount--;
    if (readcount == 0) { //所有的读进程读完，释放写的访问
        sem_post(&wsem);
    }
    sem_post(&x);
}

void *writer(void *arg) {
    int i = *((int *) arg);
   
    sem_wait(&wsem); //锁住不让其他写进程写
    printf("The %dth writer is writing...\n", i);
    sleep(3);
    sem_post(&wsem); //释放写的访问
}

int main() {
    int i;
    pthread_t rdThread[N];
    pthread_t wtThread[N];
    int rdId[N];
    int wtId[N];
    readcount = 0;
    
    //初始化信号量
    sem_init(&x, 0, 1);
    sem_init(&wsem, 0, 1);

    for (i = 0; i < N; i++) {
        rdId[i] = i;
        wtId[i] = i;
        pthread_create (&rdThread[i], NULL, reader, &rdId[i]);//创建读者线程
        pthread_create (&wtThread[i], NULL, writer, &wtId[i]);//创建写者线程
    }
    for ( i = 0; i < N; i++) {
        pthread_join(rdThread[i], NULL);//等待所有的读者线程执行完毕再结束
        pthread_join(wtThread[i], NULL);//等待所有的写者线程执行完毕再结束
    }
    return 0;
}

运行结果如下图所示：
读者优先的运行结果

2.3.2 写者优先

读者 / 写者问题（写者优先）的C语言代码实现如下：

/**************************************************************
 *问题：读者/写者问题，写者优先
 *描述：
 *1.一个进程在读的时候，其他进程也可以读。
 *2.一个进程在读/写的时候，其他进程不能进行写/读。
 *3.一个进程在写的时候，其他进程不能写。
 *4.写进程声明想写时，不允许新的读进程来访问数据
**************************************************************/
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

#define N 10  //读者N个，写者N个

int readcount;  //记录读进程的数量
int writecount; //记录写进程的数量
sem_t x;     //x控制readcount的互斥访问
sem_t y;     //y控制writecount的互斥访问
sem_t z;     //z保证写跳过读，保证写优先
sem_t wsem;  //wsem对写互斥控制
sem_t rsem;  //rsem对读互斥控制

void *reader(void *arg) {
    int i = *((int *) arg);
    sem_wait(&z);
    sem_wait(&rsem);
    sem_wait(&x);
    readcount++;
    if (readcount == 1) { //第一个读进程出现，锁住不让写
        sem_wait(&wsem);
    }
    sem_post(&x);
    sem_post(&rsem);  //释放读的访问，允许其他读者进入
    sem_post(&z);
    printf("The %dth reader is reading...\n", i);
    sleep(3);
    sem_wait(&x);
    readcount--;
    if (readcount == 0) { //所有的读进程读完，释放写的访问
        sem_post(&wsem);
    }
    sem_post(&x);
}

void *writer(void *arg) {
    int i = *((int *) arg);
    sem_wait(&y);
    writecount++;
    if(writecount == 1) { //第一个写进程，判断是否有读进程正在进行
        sem_wait(&rsem);
    }
    sem_post(&y);
    sem_wait(&wsem); //锁住不让其他写进程写
    printf("The %dth writer is writing...\n", i);
    sleep(3);
    sem_post(&wsem); //释放写的访问
    sem_wait(&y);
    writecount--;
    if (writecount == 0) { //所有写进程写完，释放读的访问
        sem_post(&rsem);
    }
    sem_post(&y);
}

int main() {
    int i;
    pthread_t rdThread[N];
    pthread_t wtThread[N];
    int rdId[N];
    int wtId[N];
    readcount = 0;
    writecount = 0;
    
    //初始化信号量
    sem_init(&x, 0, 1);
    sem_init(&y, 0, 1);  
    sem_init(&z, 0, 1);  
    sem_init(&wsem, 0, 1);
    sem_init(&rsem, 0, 1);
    
    for (i = 0; i < N; i++) {
        rdId[i] = i;
        wtId[i] = i;
        pthread_create (&rdThread[i], NULL, reader, &rdId[i]);//创建读者线程
        pthread_create (&wtThread[i], NULL, writer, &wtId[i]);//创建写者线程
    }
    for ( i = 0; i < N; i++) {
        pthread_join(rdThread[i], NULL);//等待所有的读者线程执行完毕再结束
        pthread_join(wtThread[i], NULL);//等待所有的写者线程执行完毕再结束
    }
    return 0;
}

运行结果如下图所示：
写者优先的运行结果

3. 哲学家问题

3.1 基本特点

哲学家问题的具体表现为：
有N个哲学家，他们的生活方式是交替地进行思考和进餐，哲学家们共用一张圆桌，分别坐在周围的N张椅子上，在圆桌上有N个碗和N支筷子，平时哲学家进行思考，饥饿时便试图取其左、右最靠近他的筷子，只有在他拿到两支筷子时才能进餐，进餐完毕，放下筷子又继续思考。

约束条件如下：

  1. 只有拿到两只筷子时，哲学家才能吃饭。
  2. 如果筷子已被别人拿走，则必须等别人吃完之后才能拿到筷子。
  3. 任一哲学家在自己未拿到两只筷子吃饭前，不会放下手中拿到的筷子。
  4. 用完之后将筷子返回原处。

3.2 解决思路

首先，分析其中存在的同步互斥关系：筷子是临界资源，每根筷子只能一个人取，这是互斥关系；如果筷子被取走，那么需要等待，这是同步关系。

可能出现死锁的错误解法是：设置一个信号量表示一只筷子，有N只筷子，所以设置N个信号量，哲学家每次饥饿时先试图拿左边的筷子，再试图拿右边的筷子，拿不到则等待，拿到了就吃饭，最后逐个放下筷子。这种解法下，如果N个哲学家同时感到饥饿，同时试图拿左边的筷子，都没成功；又同时试图拿右边的筷子，又都没成功，由于第3个约束条件的存在，这时出现了死锁。

因此，此问题的关键是互斥及避免死锁。在错误解法的基础上，一种可行解法是让奇数号与偶数号的哲学家拿筷子的顺序不同，破坏环路等待条件。

第二种可行的解法是只允许N-1位哲学家同时进餐，这样N-1个人都拿起一根筷子时，第N个人不能再拿筷子，就空出了一根筷子。

3.3 代码及运行结果

3.3.1 方法1

编号为奇数的哲学家先拿左手的筷子，编号为偶数的哲学家先拿右手的筷子，C语言代码实现如下：

/***********************************************************************
 *问题：哲学家问题
 *描述：
 *五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，
 *在桌子上有五个碗和五根筷子，他们的状态是思考和进餐交替，
 *平时，一个哲学家思考，饿了就取离他最近的筷子，只有拿到了两只筷子才能进餐。
 *进餐毕，放下筷子继续思考。
 *方法1：编号为奇数的哲学家先拿左手的筷子，编号为偶数的哲学家先拿右手的筷子
***********************************************************************/
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

#define N 5

/*一共N根筷子，每根筷子设置一个信号量,记录筷子的状态*/
sem_t chopsticks[N]; //1代表筷子已经被用过，0代表筷子正等待被使用

void *philosopher(void *arg) {
    int i = *((int *) arg);
    //为避免死锁，编号为奇数的哲学家先拿左手的筷子，编号为偶数的哲学家先拿右手的筷子
    if (i % 2) { //奇数编号
        sem_wait(&chopsticks[i]);  //先拿左手的筷子
		sleep(1);
        sem_wait(&chopsticks[(i + 1) % N]);  //再拿右手的筷子

        //哲学家吃啊吃
        printf("The %dth philosopher is eating...\n", i);
        sleep(3); 

        sem_post(&chopsticks[(i + 1) % N]);
		sleep(1);
        sem_post(&chopsticks[i]);
        
        //哲学家想啊想
        printf("The %dth philosopher is thinking...\n", i);
        sleep(3);  
    }
    else {
        sem_wait(&chopsticks[(i + 1) % N]);  //先拿右手的筷子
		sleep(1);
        sem_wait(&chopsticks[i]);  //再拿左手的筷子
        
        //哲学家吃啊吃
        printf("The %dth philosopher is eating...\n", i);
        sleep(3); 
        
        sem_post(&chopsticks[i]);
		sleep(1);
        sem_post(&chopsticks[(i + 1) % N]);
        
        //哲学家想啊想
        printf("The %dth philosopher is thinking...\n", i);
        sleep(3);  
    }
}

int main() {
    int i;
    pthread_t thread[N];
    int id[N];  //记录哲学家编号
    for (i = 0; i < N; i++) { //初始化信号量为1
        sem_init(&chopsticks[i], 0, 1);
    }
    for (i = 0; i < N; i++) {
        id[i] = i;
        pthread_create (&thread[i], NULL, philosopher, &id[i]);//创建线程
    }
    for ( i = 0; i < N; i++) {
        pthread_join(thread[i], NULL);//等待所有的线程执行完毕再结束
    }
    return 0;
}

运行结果如下图所示：
哲学家问题方法1运行结果

3.3.2 方法2

只允许N-1位哲学家同时进入餐厅，C语言代码实现如下：

/***********************************************************************
 *问题：哲学家问题
 *描述：
 *五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，
 *在桌子上有五个碗和五根筷子，他们的状态是思考和进餐交替，
 *平时，一个哲学家思考，饿了就取离他最近的筷子，只有拿到了两只筷子才能进餐。
 *进餐毕，放下筷子继续思考。
 *方法2：只允许4位哲学家同时进入餐厅
***********************************************************************/
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

#define N 5

/*一共N根筷子，每根筷子设置一个信号量,记录筷子的状态*/
sem_t chopsticks[N]; //1代表筷子已经被用过，0代表筷子正等待被使用
sem_t room;

void *philosopher(void *arg) {
    int i = *((int *) arg);
 
    sem_wait(&room);
	sleep(1);
    sem_wait(&chopsticks[i]);  //先拿左手的筷子
	sleep(1);
    sem_wait(&chopsticks[(i + 1) % N]);  //再拿右手的筷子

    //哲学家吃啊吃
    printf("The %dth philosopher is eating...\n", i);
    sleep(3); 

    sem_post(&chopsticks[(i + 1) % N]);
	sleep(1);
    sem_post(&chopsticks[i]);
	sleep(1);
    sem_post(&room);

    //哲学家想啊想
    printf("The %dth philosopher is thinking...\n", i);
    sleep(3);  
}

int main() {
    int i;
    pthread_t thread[N];
    int id[N];  //记录哲学家编号
    for (i = 0; i < N; i++) { //初始化筷子信号量为1
        sem_init(&chopsticks[i], 0, 1);
    }
    sem_init(&room, 0, 4);   //初始化room信号量为4
    for (i = 0; i < N; i++) {
        id[i] = i;
        pthread_create (&thread[i], NULL, philosopher, &id[i]);//创建线程
    }
    for ( i = 0; i < N; i++) {
        pthread_join(thread[i], NULL);//等待所有的线程执行完毕再结束
    }
    return 0;
}

运行结果如下图所示：
哲学家问题方法2运行结果

fufufunny
关注
  • 32
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
操作系统笔记:(九)信号量与经典同步问题
taotao 的大学墓志
04-16 1232
这节讲解操作系统用信号量机制解决同步问题，先讲解他的基本实现，然后在讲解用信号量机制解决经典的同步问题: 生产者消费者问题 读者写者问题 哲学家就餐问题 主要讲的进程同步方法如下，这一节讲信号量，下一节讲解管程remark 这一节进程和线程的概念通常是互通的，不加详细区分，仅作为CPU的调度单位信号量是什么信号量是os提供的管理同步问题的一种手段，具体来说，他有一个整数变量记录当前可供使用的标记信号
多线程代码 经典线程同步互斥问题 生产者消费者问题
06-01
a: 创建一个线程 b: 创建多个线程 c: 多线程访问同一资源 d: 经典线程同步互斥问题 e: 使用关键段解决子线程互斥问题 f: 利用事件实现线程同步问题 ...I: 信号量 semaphore 解决线程同步问题
使用同步信号量和互斥信号量解决生产者和消费者问题
kilig_CSM的博客
06-15 2643
在多线程编程中，同步信号量（synchronization semaphore）和互斥信号量（mutex semaphore）是两种常用的同步机制。它们都是通过操作信号量来实现线程之间的同步和互斥访问共享资源。同步信号量（Synchronization Semaphore）： 同步信号量用于实现线程之间的同步，确保线程按照特定的顺序执行。
利用信号量机制实现生产者消费者问题（用进程通信进行模拟）
qq_41648012的博客
06-02 5974
生产者消费者同步问题：生产者进程产生消息放在某个共享资源区，共享资源区的消息不为空时消费者进程从该共享资源区读取消息，为了避免脏读生产者和消费者不能同时访问共享资源，这就涉及到生产者和消费者进程之间的同步。利用信号量解决该问题： 定义两个信号量（不能是一个，否则生产者或者消费者可能会无限的访问共享资源，形成死循环）S1、S2，初始值为1，0。S1=1表示生产者进程可写共享资源，为0则不可；S2=1...
用信号量解决进程同步互斥
qq_74059564的博客
04-19 404
先引进锁这个概率，锁是用来解决临界区互斥访问的一个简单工具。通过进程访问某临界区，需先对其上锁lock，进程结束时释放锁release，在上锁时不允许别的进程访问，在释放完后，后续的进程才可访问。这样的工具称为互斥锁。但其缺点是忙等待。
【操作系统】信号量解决经典同步问题
fjtooo的博客
11-10 7369
文章目录1. 基本结构2. P,V操作3. 信号量的应用3.1 信号量实现进程互斥3.2 信号量实现前驱关系4. 用信号量解经典同步问题4.1 生产者消费者问题4.2 读者写者问题4.3 狒狒过桥问题4.4 理发师理发问题4.5 哲学家进餐问题 信号量机制是Dijkstra提出的一种卓有成效的进程同步工具。信号量有整形信号量、记录型信号量、AND型信号量等，这里主要介绍我们常见的记录型信号量。 1...
经典利用信号量实现同步的问题
每天学习一点点，成长一小步
08-22 1768
1、生产者–消费者问题问题描述:生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。本作业要求设计在同一个进程地址空间内执行的两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。
信号量解决经典线程同步问题
ccnunlp的专栏
08-17 508
      信号量 是E. W.Dijkstra在l965年提出的一种方法，它使用一个整型变量来累计唤醒次数，以供以后使用。在他的建议中引入一个新的变号类型，称作信号量(semapore )。一个信号量的值可以为0,表示没有积累下来的唤醒操作;或者为正值，表示有一个或多个被积累下来的唤醒操作。      Dijkstra建议设两种操作:Down和Up。对一信号量执行Down操作是检查其值是...
五、深入了解信号量机制（大彻大悟篇）内附经典生产者消费者等线程同步问题
猿小许的博客
08-24 9791
一、信号量机制 复习回顾+思考:之前学习的这些进程互斥的解决方案分别存在哪些问题? 进程互斥的四种软件实现方式(单标志法、双标志先检查、双标志后检查、Peterson算法 ) 进程互斥的三种硬件实现方式(中断屏蔽方法、TS/TSL指令 、Swap/XCHG指令 ) 1.在双标志先检查法中，进入区的“检查”、“ 上锁”操作无法一气呵成，从而导致了两个进程有可能同时进入临界区的问题; 2.所有的解决方案都无法实现“让权等待” 1.1 什么是信号量 信号量其实就是一个变量(可以是一个整数， 也可以是更复杂的记
C语言信号量同步与互斥生产者消费者互斥锁读写者问题哲学家就餐问题课程设计
04-20
本课程设计旨在通过C语言编程来解决信号量机制下的同步、互斥、生产者消费者问题、哲学家就餐问题和读写者问题。 一、信号量机制 信号量机制是操作系统中的一种同步机制，它用于控制多个进程或线程的访问共享资源...
8. 递归互斥信号量.zip
01-17
在FreeRTOS操作系统中，信号量是一种非常重要的同步和资源管理机制。递归互斥信号量是其中的一个特殊类型，主要用于解决多线程环境中的资源竞争问题。递归互斥信号量允许同一任务在已获得该信号量的情况下再次请求并...
java同步互斥信号量问题
11-01
总结来说，Java同步互斥和信号量是解决多线程环境下资源访问冲突的重要工具。信号量提供了更灵活的控制，可以管理多个许可证，而不仅仅是二进制锁。理解这些概念并正确使用它们对于编写健壮、高效的多线程程序至关...
用有名信号量和匿名信号量实现进程互斥
02-24
总结来说，信号量机制通过管理资源的访问权，确保了进程之间的互斥。在C语言中，通过使用`sem_init`、`sem_post`、`sem_wait`和`sem_destroy`这些函数，我们可以有效地控制进程对共享资源的访问，防止数据竞争和死锁...
实现进程互斥和同步的信号量机制
m0_63141132的博客
05-16 1464
利用硬件技术和信号量机制实现进程同步机制、实现进程互斥和同步的信号量机制
【操作系统】信号量学习笔记（三）：生产者-消费者问题及其变式
KARLGong的博客
07-05 304
操作系统课程信号量部分（生产者-消费者问题）的笔记，参考了Allen B. Downey的The Little Book of Semaphores一书。
【持续集成_05课_Linux部署SonarQube及结合开发项目部署】
weixin_42333261的博客
07-12 313
前置条件：sonarQube不能使用root账号进行启动，所以需要创建普通用户及。3）CMD上传qube文件-不能传到home路径下哦。2）添加用户、组名、密码。4）检查并解压上传的包。
看ros的某个节点发出的信息的linux指令
嵌入式行业打工人，不定期更新博客。
07-11 329
在ROS (Robot Operating System) 中，如果你想查看某个特定节点发布到某个话题上的消息，你可以使用。命令，但是这将显示关于节点的一般信息，而不是它发布的消息数据。请记住，为了使用这些命令，你需要确保你的ROS环境已经被正确设置，通常是通过运行。这个命令可以让你实时地看到一个话题上发布的消息数据。确保替换上述命令中的路径为你实际的ROS工作空间路径。如果你不确定消息的类型，可以先用。如果你知道消息的类型，也可以加上。此外，如果你想查看节点的日志信息，可以使用。假设你想要查看由节点。
操作系统核心之存储与控制
最新发布
yuanwu932730169的博客
07-16 199
在操作系统中，存储和控制是两个核心功能，它们共同支持着系统的正常运行和高效管理。
第二节 shell脚本基础(5)(6)(7)
weixin_73298423的博客
07-15 346
shell的执行方式,调试和退出值

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fufufunny

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值