南京邮电大学操作系统实验二:线程的互斥与同步

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

实验原理及内容

基于互斥锁的临界区管理

  1. 使用编辑器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. 单缓冲区

生产者和消费者共享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

  1. 代码说明:

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

sem_t:信号量的数据类型

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

该函数第一个参数为信号量指针,第二个参数为信号量类型(一般设置为0),第三个为信号量初始值。第二个参数pshared0时,该进程内所有线程可用,不为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个缓冲区,则两个线程交替访问执行。

  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()函数的执行结果有所差别。

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

  1. 问题描述:

一个能放N(这里N设为3)个水果的盘子,爸爸只往盘子里放苹果,妈妈只放橙子,女儿只吃盘子里的苹果,儿子只吃橙子。采用三个信号量:

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

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

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

互斥量work_mutexprintf输出时能够保持一致。

  1. 创建新的源代码文件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;
}

运行结果如下:

 基于信号量semid1,semid2semid1代表车,semid2代表门)解决司机-售票员问题,对相应的信号量进行sem_post()sem_wait ()实现程序功能。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

cookie爱吃小饼干

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

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

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

打赏作者

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

抵扣说明:

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

余额充值