南京邮电大学操作系统实验二：线程的互斥与同步_2、生产者和消费者共享1个缓冲区,使用之前学过的方法创建两个线程分别作为生产者-CSDN博客

本文链接：https://blog.csdn.net/m0_54848805/article/details/121588174

本文通过一系列示例代码详细介绍了多线程编程中的同步问题，包括基于互斥锁的临界区管理、信号量实现的生产者-消费者模型以及苹果-桔子问题和司机-售票员问题的解决方案。通过这些例子，展示了如何使用互斥锁和信号量确保线程安全，避免数据竞争，实现线程间的同步与协作。

摘要由CSDN通过智能技术生成

实验原理及内容

基于互斥锁的临界区管理

使用编辑器gedit 2_1.c，新建一个2_1.c源文件，创建双线程并发完成订票操作，输入后面的范例代码：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int ticketAmount = 2; //Global Variable
void* ticketAgent(void* arg){
    int t = ticketAmount;
    if (t > 0)
    {
        printf("One ticket sold!\n");
        t--;
    }else{
        printf("Ticket sold out!!\n");
    }
    ticketAmount = t;
    pthread_exit(0);
}
int main(int argc, char const *argv[])
{
pthread_t ticketAgent_tid[2];
//基于同一个线程函数，通过循环创建两个线程
    for (int i = 0; i < 2; ++i)
    {
        pthread_create(ticketAgent_tid+i, NULL, ticketAgent,NULL);
}
//循环等待所有线程结束
    for (int i = 0; i < 2; ++i)
    {
        pthread_join(ticketAgent_tid[i],NULL);
    }
    printf("The left ticket is %d\n", ticketAmount);
    return 0;
}

两个线程作为售票终端共享一个全局变量ticketAmount，两个线程运行结束后在主线程中打印余票量，编译并多次运行这份代码，观察结果，说明原因，思考线程函数中临界区的范围。

多次运行2_1.c后出现剩余票数为1的结果输出，由于两个线程同时访问了临界区。

(2)基于互斥锁的临界区互斥访问

对线程函数中的临界区，使用pthread库中的互斥锁实现临界区的互斥访问。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int ticketAmount = 2; //Global Variable
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; //Global lock
void* ticketAgent(void* arg){
    pthread_mutex_lock(&lock);
    int t = ticketAmount;
    if (t > 0)
    {
        printf("One ticket sold!\n");
        t--;
    }else{
        printf("Ticket sold out!!\n");
    }
    ticketAmount = t;
    pthread_mutex_unlock(&lock);
    pthread_exit(0);
}
int main(int argc, char const *argv[])
{
    pthread_t ticketAgent_tid[2];
    for (int i = 0; i < 2; ++i)
    {
        pthread_create(ticketAgent_tid+i, NULL, ticketAgent,NULL);
    }
    for (int i = 0; i < 2; ++i)
    {
        pthread_join(ticketAgent_tid[i],NULL);
    }
    printf("The left ticket is %d\n", ticketAmount);
    return 0;
}

代码说明：

a. pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; //创建一个互斥锁

b. pthread_mutex_lock(&lock); //上锁

c. pthread_mutex_unlock(&lock); //开锁

通过基于互斥锁的临界区的互斥访问，有效解决了两个线程同时访问临界区的问题，可以正确输出结果。

基于信号量的生产者-消费者同步

单缓冲区

生产者和消费者共享1个缓冲区，使用之前学过的方法创建两个线程分别作为生产者和消费者。创建新的源代码文件2_2.c，内容如下:

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>   //信号量头文件
//定义同步信号量变量（全局变量）
sem_t empty;
sem_t full;
//生产者线程函数
void* producerThd(void* arg){
    for(int i=0; i<10; i++){
        printf("**Producing one item.**\n");
        sem_wait(&empty);   //P(empty)
        printf("**PUTTING item %d to warehouse.**\n",i+1);
        sem_post(&full);     //V(full)
    }  
    pthread_exit(0); }
void* consumerThd(void* arg){
    for(int i=0; i<10; i++){
        sem_wait(&full);  //P(full)
        printf("##GETTING item %d from warehouse.##\n",i+1);
        sem_post(&empty);  //V(empty)
        printf("##Consuming the item.##\n");
    }  
    pthread_exit(0);
}
int main(int argc, char *argv[]) {
    pthread_t producer_tid, consumer_tid;
    //信号量初始化
    sem_init(&empty, 0, 1);
    sem_init(&full,  0, 0);  
    pthread_create(&producer_tid, NULL, producerThd, NULL);
    pthread_create(&consumer_tid, NULL, consumerThd, NULL);
    pthread_join(producer_tid, NULL);
    pthread_join(consumer_tid, NULL);
    //销毁信号量
    sem_destroy(&empty);
    sem_destroy(&full);
}

使用下面的命令进行编译生成可执行文件，运行程序。

gcc 2_2.c -o 2_2 -pthread

./2_2

代码说明：

要使用信号量，请先包含头文件<semaphore.h>

sem_t：信号量的数据类型

int sem_init(sem_t *sem, int pshared, unsigned int val);

该函数第一个参数为信号量指针，第二个参数为信号量类型（一般设置为0），第三个为信号量初始值。第二个参数pshared为0时，该进程内所有线程可用，不为0时不同进程间可用。

int sem_wait(sem_t *sem);

该函数申请一个信号量，当前无可用信号量则等待，有可用信号量时占用一个信号量，对信号量的值减1。

int sem_post(sem_t *sem);

该函数释放一个信号量，信号量的值加1。

int sem_destory(sem_t *sem);

该函数销毁信号量。

int sem_wait(sem_t *sem);

该函数申请一个信号量，当前无可用信号量则等待，有可用信号量时占用一个信号量，对信号量的值减1。相当与P操作。

int sem_post(sem_t *sem);

该函数释放一个信号量，信号量的值加1。相当于V操作。

由于是生产者和消费者共享1个缓冲区，则两个线程交替访问执行。

多缓冲区

当生产者和消费者共享多个缓冲区时，设Bank[10]为仓库，有10个位置放置商品，元素为0表示为空，为1时表示有商品，除了要用信号量同步外，还要加入互斥操作保护临界区。创建新的源代码文件2_3.c，代码如下：

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
void printBank();  //该函数用以输出缓冲区的全部数值
int Bank[10]={0};
int in=0,out=0;  
sem_t empty;
sem_t full;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void* producerThd(void* arg){
    for(int i=0; i<30; i++){       
        sem_wait(&empty);
        pthread_mutex_lock(&lock); //临界区开始
        Bank[in] = 1;
        in = (in+1)%10;
        printBank();
      pthread_mutex_unlock(&lock);//临界区结束
        sem_post(&full);
    }  
    pthread_exit(0);
}
void* consumerThd(void* arg){
    for(int i=0; i<30; i++){
        sem_wait(&full);
        pthread_mutex_lock(&lock); //临界区开始
        Bank[out] = 0;
        out = (out+1)%10;
        printBank();
       pthread_mutex_unlock(&lock);//临界区结束
        sem_post(&empty);
    }  
    pthread_exit(0);
}
/*该函数用以输出缓冲区的全部数值*/
void printBank(){
    printf("Bank:");
    for(int i=0; i<10; i++){
        printf("[%d]",Bank[i]);
        if(i==9) putchar('\n');
    }
}
int main(int argc, char *argv[]) {
    pthread_t producer_tid, consumer_tid;
    sem_init(&empty, 0, 10);
    sem_init(&full,  0, 0);
    pthread_create(&producer_tid, NULL, producerThd, NULL);
    pthread_create(&consumer_tid, NULL, consumerThd, NULL);
    pthread_join(producer_tid, NULL);
    pthread_join(consumer_tid, NULL);
    sem_destroy(&empty);
    sem_destroy(&full);
}

编译并运行程序，可以尝试在生产者、消费者线程函数中添加sleep( )函数调用，调节执行速度，观察执行结果。

在线程函数中调用sleep(1),对比未调用sleep()函数的结果发现输出值不同。

生产、消费在一个时间片内运行for循环输出完成，两线程交替执行。

单核情况下，sleep（second）函数线程告诉操作系统，在second秒内，自身不需要调度，不要给自身分配时间片，使该进程挂起，其它进程得到cpu资源。

调用sleep（）函数，使得一个进程时间片用完后，另一个进程开始执行，会与不调用sleep()函数的执行结果有所差别。

基于信号量解决苹果-桔子问题

问题描述：

一个能放N（这里N设为3）个水果的盘子，爸爸只往盘子里放苹果，妈妈只放橙子，女儿只吃盘子里的苹果，儿子只吃橙子。采用三个信号量：

sem_t empty:信号量empty控制盘子可放水果数，初始为3，因为开始盘子为空可放水果数为3。

sem_t apple ;信号量apple控制女儿可吃的苹果数，初始为0，因为开始盘子里没苹果。

sem_t orange;信号量orange控制儿子可吃的橙子是，初始为0，因为开始盘子里没橙子。

互斥量work_mutex为printf输出时能够保持一致。

创建新的源代码文件2_4.c，参考源码如下：

#include <stdio.h> 
#include <pthread.h> 
#include <semaphore.h> 
#include <unistd.h> 
sem_t empty; //控制盘子里可放的水果数 
sem_t apple; //控制苹果数 
sem_t orange; //控制橙子数 
pthread_mutex_t work_mutex=PTHREAD_MUTEX_INITIALIZER; //声明互斥量work_mutex 
int fruitCount = 0;//盘子中水果的数量 

void *thread_f(void *arg) //father线程 
{ 
while(1)
{ 
sem_wait(&empty); //占用一个盘子空间，可放水果数减1 
pthread_mutex_lock(&work_mutex); //加锁 
printf("爸爸放入一个苹果!（盘子当前水果总数：%d）\n", ++fruitCount); 
sem_post(&apple); //释放一个apple信号了，可吃苹果数加1 
pthread_mutex_unlock(&work_mutex); //解锁 
sleep(0.1); 
} 
} 

void * thread_m(void *arg) //mother线程 
{ 
while(1){ 
sem_wait(&empty); 
pthread_mutex_lock(&work_mutex); //加锁 
printf("妈妈放入一个橙子!（盘子当前水果总数：%d）\n", ++fruitCount); 
sem_post(&orange); 
pthread_mutex_unlock(&work_mutex); //解锁 
sleep(0.2); 
} 
} 
void * thread_s(void *arg) //son线程 
{ 
while(1){ 
sem_wait(&orange); //占用一个橙子信号量，可吃橙子数减1 
pthread_mutex_lock(&work_mutex); //加锁 
printf("儿子吃了一个橙子!（盘子当前水果总数：%d）\n", --fruitCount); 
sem_post(&empty); //吃了一个橙子，释放一个盘子空间，可放水果数加1 
pthread_mutex_unlock(&work_mutex); //解锁 
sleep(0.2); 
} 
} 
void * thread_d(void *arg) //daughter线程 
{ 
while(1){ 
sem_wait(&apple); 
pthread_mutex_lock(&work_mutex); //加锁 
printf("女儿吃了一个苹果!（盘子当前水果总数：%d）\n", --fruitCount); 
sem_post(&empty); 
pthread_mutex_unlock(&work_mutex); //解锁 
sleep(0.1); 
} 
} 
int main() 
{ 
pthread_t father; //定义线程 
pthread_t mother; 
pthread_t son; 
pthread_t daughter; 
sem_init(&empty, 0, 3); //信号量初始化 
sem_init(&apple, 0, 0); 
sem_init(&orange, 0, 0); 
pthread_create(&father,NULL, thread_f,NULL); //创建线程 
pthread_create(&mother,NULL, thread_m,NULL); 
pthread_create(&daughter,NULL, thread_d,NULL); 
pthread_create(&son,NULL, thread_s,NULL); 
sleep(1); 
sem_destroy(&empty); 
sem_destroy(&apple); 
sem_destroy(&orange); 
return 0; 
}

编译并多次运行该程序，给出执行结果，思考执行情况。

使用互斥信号量work_mutex ，进行pthread_mutex_lock(&work_mutex); //加锁、pthread_mutex_unlock(&work_mutex); //解锁，实现了四个进程对临界资源fruitCount的互斥访问。

基于信号量的的临界区管理

修改2_1.c，尝试使用信号量解决订票线程的同步问题，给出源代码及实行结果。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>
int ticketAmount = 2;               //Global Variable 
sem_t mutex;                      //互斥信号量

void* ticketAgent(void* arg){
    sem_wait(&mutex);            //P(mutex)
    int t = ticketAmount;
    if (t > 0)
    {
        printf("One ticket sold!\n");
        t--;
    }else{
        printf("Ticket sold out!!\n");
    }
    ticketAmount = t;
    sem_post(&mutex);                   //V(mutex)
    pthread_exit(0);
}

int main(int argc, char const *argv[])
{
pthread_t ticketAgent_tid[2];
sem_init(&mutex,0,1);                      //初始化信号量为1
//基于同一个线程函数，通过循环创建两个线程
    for (int i = 0; i < 2; ++i)
    {
        pthread_create(ticketAgent_tid+i, NULL, ticketAgent,NULL); 
}
//循环等待所有线程结束
    for (int i = 0; i < 2; ++i)
    {
        pthread_join(ticketAgent_tid[i],NULL);
    }
    printf("The left ticket is %d\n", ticketAmount);
    sem_destroy(&mutex);                 //撤销信号量
    return 0;
}

运行结果如下：

基于信号量解决司机-售票员问题

创建新的源代码文件2_5.c，通过信号量机制实现课堂PPT中所述司机和售票员的同步过程。

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
sem_t semid1,semid2;//Semid1车；Semid2门
void* driver()
{
int n=6;
 while(n)
 {
     n--;
     printf("\n");
     sem_wait(&semid1);
     printf("司机启动汽车\n");
     printf("司机正常行车\n");
     printf("司机到站停车\n");
     sem_post(&semid2);
 }
}
void* passenger()
{
int n=6;
 while(n)
 {
     n--;
     printf("售票员关车门\n");
     sem_post(&semid1);
     printf("售票员售票\n");
     sem_wait (&semid2); 
     printf("售票员开车门\n");
 }
}
int main()
{
 sem_init(&semid1,0,0);
 sem_init(&semid2,0,0);
 
 pthread_t tid1,tid2;
 
 pthread_create(&tid1,0,driver,0);
 pthread_create(&tid2,0,passenger,0);
 pthread_join(tid1,(void**)0);
 pthread_join(tid2,(void**)0);
return 0;
}

运行结果如下：