进程同步问题

最新推荐文章于 2021-11-28 11:05:24 发布
最新推荐文章于 2021-11-28 11:05:24 发布
阅读量157 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hunhunee666/article/details/120257021
版权

目录

生产者消费者模型

读者作者模型

总结

生产者消费者模型

问题描述

  • 当缓冲区满时，生产者不能进入临界区生产（同步）
  • 当缓冲区空时，消费者不能进入临界区消费（同步）
  • 由于只考虑了一个生产者，一个消费者，互斥问题不存在

原型

方法--声明一个长度为 n 的数组，但只能使用其中 n-1 个空间

缺点--n个空间没有用完；忙等待

#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>    /*srand*/
#include<unistd.h>    /*sleep*/

#define BUFFER_SIZE 10
int buffer[BUFFER_SIZE];
int in = 0;
int out = 0;

void *producer(void *arg){
    while(1){
        while(((in + 1)%BUFFER_SIZE)==out){
            // 缓冲区已满
            printf("full\n");
            sleep(1);
        }
        int item = rand() % 10;
        buffer[in] = item;
        printf("producing an item %d......\n", item);
        in = (in + 1) % BUFFER_SIZE;
        sleep(1);
    }
}

void *consumer(void *arg){
    while(1){
        while(in == out){
            // 缓冲区为空
            printf("empty\n");
            sleep(1);
        }
        int item = buffer[out];
        printf("\t\t\t\tconsuming an item %d......\n", item);
        out = (out + 1) % BUFFER_SIZE;
        sleep(1);
    }
}

int main(){
    srand((unsigned)time(NULL));
    pthread_t tid_producer, tid_consumer;
    pthread_create(&tid_producer, 0, producer, NULL);
    pthread_create(&tid_consumer, 0, consumer, NULL);
    pthread_join(tid_producer, NULL);
    pthread_join(tid_consumer, NULL);
    return 0;
}

第一次尝试

方法--用一个变量 counter 来计数

缺点--race

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

#define BUFFER_SIZE 10
int buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
int counter = 0;

void *producer(void *arg){
    while(1){
        while(counter == BUFFER_SIZE){
            // 缓冲区已满
            printf("full\n");
            sleep(1);
        }
        int item = rand() % 10;
        buffer[in] = item;
        printf("producing an item %d......\n", item);
        in = (in + 1) % BUFFER_SIZE;
        counter++;
        sleep(1);
    }
}

void *consumer(void *arg){
    while(1){
        while(counter == 0){
            // 缓冲区为空
            printf("empty\n");
            sleep(1);
        }
        int item = buffer[out];
        printf("\t\t\t\tconsuming an item %d......\n", item);
        out = (out + 1) % BUFFER_SIZE;
        counter--;    
        sleep(1);
    }
}

int main(){
    srand((unsigned)time(NULL));
    pthread_t tid_producer, tid_consumer;
    pthread_create(&tid_producer, 0, producer, NULL);
    pthread_create(&tid_consumer, 0, consumer, NULL);
    pthread_join(tid_producer, NULL);
    pthread_join(tid_consumer, NULL);
    return 0;
}

第二次尝试

方法--信号量解决同步问题

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

#define BUFFER_SIZE 10
int buffer[BUFFER_SIZE];    // 共享变量
int in = 0;
int out = 0;
sem_t empty, full, mutex;


void *producer(void *arg){
    while(1){
        int item = rand() % 10;
        sem_wait(&empty);
        sem_wait(&mutex);
        buffer[in] = item;
        printf("producing an item %d......\n", item);
        sem_post(&mutex);
        sem_post(&full);    
        in = (in + 1) % BUFFER_SIZE;
        
        sleep(1);
    }
}

void *consumer(void *arg){
    while(1){
        sem_wait(&full);
        sem_wait(&mutex);
        int item = buffer[out];
        printf("\t\t\t\tconsuming an item %d......\n", item);
        sem_post(&mutex);
        sem_post(&empty);
        out = (out + 1) % BUFFER_SIZE;
        sleep(1);
    }
}

int main(){
    sem_init(&empty, 0, BUFFER_SIZE);
    sem_init(&full, 0, 0);
    sem_init(&mutex, 0, 1);
    srand((unsigned)time(NULL));
    pthread_t tid_producer, tid_consumer;
    pthread_create(&tid_producer, 0, producer, NULL);
    pthread_create(&tid_consumer, 0, consumer, NULL);
    pthread_join(tid_producer, NULL);
    pthread_join(tid_consumer, NULL);
    sem_destroy(&empty);
    sem_destroy(&full);
    sem_destroy(&mutex);
    return 0;
}

读者作者模型

问题描述

  • 某一时刻，可以有多个读者进入临界区阅读（同步）
  • 某一时刻，有且仅有一个作家能够进入临界区写作（同步）
  • 某一时刻，当有作家在临界区内写作，读者不能进入临界区阅读（互斥）
  • 某一时刻，当有读者在临界区内阅读，或有其他作家在临界区内写作，作家不能进入临界区写作（互斥）

原型

缺点--同步问题和互斥问题都没有解决。

#include<pthread.h>
#include<stdio.h>
#include<unistd.h>  /*sleep*/

void *writer(void *arg){
    while(1){
        /* critical section */
        printf("\t\t\t\twriting is performed......\n");
        sleep(1);
    }
}

void *reader(void *arg){
    while(1){      
        /* critical section */
        printf("reading is performed......\n");
        sleep(1);
    }
}

int main(){
    pthread_t tid_writer[2], tid_reader[5];
    for(int i = 0; i < 2; i++){
        pthread_create(&tid_writer[i], NULL, writer, NULL);
    }
    for(int j = 0; j < 3; j++){
        pthread_create(&tid_reader[j], NULL, reader, NULL);
    }
    for(int i = 0; i < 2; i++){
        pthread_join(tid_writer[i], NULL);
    }
    for(int j = 0; j < 3; j++){
        pthread_join(tid_reader[j], NULL);
    }
    return 0;
}

第一次尝试

方法--声明一个信号量rw_mutex解决同步问题和互斥问题

缺点--

  1. 读者的同步问题没有完全解决

    考虑以下情形：

    作者进入临界区写作，此时，有大批读者在等待进入临界区（卡在sem_wait处）。

    当作者退出临界区时，卡在临界区外的读者（不考虑新来的读者）只有一个能够进入临界区，违背同步。

  2. 引入了另一个共享变量read_count，但没有进行保护

分析错误原因--允许多个读者执行执行P操作(sem_init)，实际上只需要第一个读者执行P操作

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

int read_count = 0;
sem_t rw_mutex;

void *writer(void *arg){
    while(1){
        sem_wait(&rw_mutex);
        /* critical section */
        printf("\t\t\t\twriting is performed......\n");
        sem_post(&rw_mutex);
        sleep(1);
    }
}

void *reader(void *arg){
    while(1){
        if(read_count == 0){
            sem_wait(&rw_mutex);
        }
        read_count++;
        /* critical section */
        printf("reading is performed......\n");
        read_count--;
        if(read_count == 0){
            sem_post(&rw_mutex);
        }
        sleep(1);
    }
}

int main(){
    sem_init(&rw_mutex, 0, 1);
    pthread_t tid_writer[2], tid_reader[5];
    for(int i = 0; i < 2; i++){
        pthread_create(&tid_writer[i], NULL, writer, NULL);
    }   
    for(int j = 0; j < 3; j++){
        pthread_create(&tid_reader[j], NULL, reader, NULL);
    }
    for(int i = 0; i < 2; i++){
        pthread_join(tid_writer[i], NULL);
    }
    for(int j = 0; j < 3; j++){
        pthread_join(tid_reader[j], NULL);
    }
    sem_destroy(&rw_mutex);
    return 0;
}

第二次尝试

方法--声明另一个信号量mutex，只允许一个读者进行P操作（sem_init)，同时保护共享变量read_count

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

int read_count = 0;
sem_t rw_mutex;
sem_t mutex;

void *writer(void *arg){
    while(1){
        sem_wait(&rw_mutex);
        /* critical section */
        printf("\t\t\t\twriting is performed......\n");
        sem_post(&rw_mutex);
        sleep(1);
    }
}

void *reader(void *arg){
    while(1){
        sem_wait(&mutex);
        if(read_count == 0){
            sem_wait(&rw_mutex);
        }
        read_count++;
        sem_post(&mutex);
        /* critical section */
        printf("reading is performed......\n");
        sem_wait(&mutex);
        read_count--;
        if(read_count == 0){
            sem_post(&rw_mutex);
        }
        sem_post(&mutex);
        sleep(1);
    }
}

int main(){
    sem_init(&rw_mutex, 0, 1);
    sem_init(&mutex, 0, 1);
    pthread_t tid_writer[2], tid_reader[5];
    for(int i = 0; i < 2; i++){
        pthread_create(&tid_writer[i], NULL, writer, NULL);
    }
    for(int j = 0; j < 3; j++){
        pthread_create(&tid_reader[j], NULL, reader, NULL);
    }
    for(int i = 0; i < 2; i++){
        pthread_join(tid_writer[i], NULL);
    }
    for(int j = 0; j < 3; j++){
        pthread_join(tid_reader[j], NULL);
    }
    sem_destroy(&rw_mutex);
    sem_destroy(&mutex);
    return 0;
}

总结

  • 协作进程需要解决通信和同步问题。
  • 通信可以通过共享内存和消息传递(比如管道、套接字、远程过程调用)的方式。
  • 同步问题一般通过信号量的方式解决。
  • 同步问题有时伴随着互斥问题，一般来说，同步比互斥更加困难，在考虑同步和互斥问题时，优先解决同步，再解决互斥。
  • 即使有了信号量这个工具，解决同步问题仍然是很棘手的，通过调试的方式几乎不能发现错误，只能通过严密的逻辑思考去尽可能减少错误。
浑浑噩噩666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统进程同步问题
02-04
操作系统进程同步问题
多线程编程（Linux C）
u014426028的博客
04-21 218
多线程编程（Linux C） 多线程编程可以说每个程序员的基本功，同时也是开发中的难点之一，本文以Linux C为例，讲述了线程的创建及常用的几种线程同步的方式，最后对多线程编程进行了总结与思考并给出代码示例。 一、创建线程 多线程编程的第一步，创建线程。创建线程其实是增加了一个控制流程，使得同一进程中存在多个控制流程并发或者并行执行。 线程创建函数，其他函数这里不再列出，可以参...
生产者-消费者信号量问题
KEEP PERFECTING MYSELF
11-20 622
#include #include #include #include #include #define N 10 struct Product{ int value; int ID; }buffer[N]; sem_t mutex; sem_t empty; sem_t full; int in=0,out=0; int productID=0; #define random(x)
Linux进程创建及同步实验（fork()函数使用，生产者-消费者问题的p，v操作）
热门推荐
sunrise的博客
06-27 4万+
实验1：编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个出现输出不同的内容。试观察并记录显示结果，并分析原因。 fork()函数说明： 函数通过系统调用创建一个与原来进程几乎完全相同的进程，这个新产生的进程称为子进程。一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然...
生产者与消费者
心中天堂的专栏
05-05 706
<br />include<stdio.h><br />#include<pthread.h><br />#include<sys/types.h><br />#include<unistd.h><br />#include<semaphore.h><br />#include<stdlib.h><br />#define SIZE_OF_BUFFER 10<br />int buffer[SIZE_OF_BUFFER];//缓冲数组<br />int in=0,out=0;//采用循环队列方式进行数组的访
Linux的共享内存
HideInTime的博客
02-19 709
一、shm方式和mmap方式区分 二者本质上是类似的，mmap可以看到文件的实体，而 shmget 对应的文件在交换分区上的 shm 文件系统内，无法直接 cat 查看 安全性：mmap 方式对应的真实文件，如果用户有权限即可查看，甚至删除 shmget 方式其实也一样，好了一层皮罢了（ipcrm -m …） 一致性：mmap 方式下各进程映射文件的相同部分可以共享内存 shmget 时各个进程共享同一片内存区...
进程同步实验报告
04-02
（1）了解操作系统进程同步的基本概念和准则。 （2）理解信号量机制及P、V操作含义。 （3）了解经典进程同步问题，掌握信号量方法解决进程同步问题的方法。 包括实验目的，截图，心得体会，代码
操作系统 进程同步问题精讲（免费下载）
02-15
操作系统 进程同步问题精讲（免费下载）
经典进程同步问题（代码+文档）
06-29
实现经典同步的三个问题 在linux下全部能成功实现，使用的是两种信号量机制。
在Linux系统下生产者消费者,操作系统实验之linux下实现生产者与消费者问题
weixin_39610188的博客
04-28 284
在buffer.h中的代码如下：typedef int buffer_item;#define BUFFER_SIZE 5#define MAX_PRODUCER 20#define MAX_CONSUMER 20在MainDriver.cpp中的代码如下：#include #include#include #include #include typedef int buffer_item;#d...
生产者消费者问题
lishichengyan的博客
11-02 527
这是进程/线程同步与互斥中最简单、最经典的一个例子，也被叫做“有限缓冲区”问题。 假定现在有一个“有限缓冲池”（最讨厌这种fancy word-_-+，其实就是空间有限的一块地方吧），生产者负责往里面投放资源，消费者负责把资源拿走（这样的模型很常见，比如说打字，你就是一个生产者，负责往IO缓冲区写东西，处理这个缓冲区的程序就是消费者，负责把你输入的东西拿出来显示到屏幕上）。这里会出现几个问题：
进程同步
amf12345的博客
08-29 333
引入进程后，虽然使系统中的多道程序并发执行，有效地改善资源利用率，显著地提高系统的吞吐量，但却使系统变得更加复杂。如果不能采取有效的措施（同步），对并发进程的运行进行管理，将对系统资源的无序争夺给系统造成混乱，使并发处理的结果存在着不确定性。 进程同步的基本概念 　　1. 两种形式的制约关系 　　1) 间接相互制约关系 　　2) 直接相互制约关系 　　2. 临界资源(Critical Resou...
操作系统概念 进程同步（有限缓存解决方案）
苹果醋黑作坊
04-28 341
while(true){ /*produce an item in nextProduced */ while(counter == BUFFER_SIZE) ;/*do nothing*/ buffer[in] = nextProduced; in = (in+1)%BUFFER_SIZE; counter++; }以上是生产者进程代码消费者进程代码while(true){ while(coun...
南京邮电大学操作系统实验二：线程的互斥与同步
m0_54848805的博客
11-28 1918
实验原理及内容 基于互斥锁的临界区管理 使用编辑器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; i...
操作系统经典同步互斥问题——生产者消费者问题
chongkuachan8070的博客
10-17 116
linux下的同步和互斥 tags: Linux sync_mutex Semaphore.h 一份好文档，胜读十年书 本文参考了诸多资料，百度百科，cplusplus等 首先介绍一个头文件#include <semaphore.h> 这里面包含了大多数的所需要使用的信...
Linux系统编程笔记：线程同步
weixin_43952192的博客
05-23 215
线程同步 一、基本概念 1.1线程同步 线程不同步导致共享数据混乱，是由于资源共享、调度随机，缺乏同步机制。 情景：程序中有一个全局变量Val，且有两个线程，线程A需要对变量Val进行读取操作，线程B需要对变量Val进行写操作，此时可能会出现对Val资源的抢夺，会导致不能按照客户的意愿进行下去，这时就需要实行线程同步。 线程同步：协同步调，对公共区域数据按序访问。防止数据混乱，产生与时间有关的错误。 1.2线程同步的方式 常见的线程同步方法有：互斥锁、条件变量、信号量等。 二、同步方法：互斥锁（互斥量） 为
linux线程7（manufacturer and consumer）
onlyou2030的博客
09-29 344
问题描述：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经放入产品的缓冲区中再次投放产品。 首先假设简单的情况，生产者和消费者只有一个，
经典进程同步问题C语言
最新发布
05-25
经典的进程同步问题通常包括生产者-消费者问题、读者-写者问题和哲学家就餐问题等。这里以生产者-消费者问题为例，简单介绍一下如何在 C 语言中实现进程同步。 生产者-消费者问题是指多个进程共享同一个缓冲区，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值