操作系统上机编程2-----unixc实现进程同步

撰写时间:2017.6.10
通过信号量机制和条件变量机制实现进程同步

pc1.c: 使用条件变量解决生产者、计算者、消费者问题

• 系统中有3个线程：生产者、计算者、消费者
• 系统中有2个容量为4的缓冲区：buffer1、buffer2
• 生产者生产’a’、’b’、’c’、‘d’、’e’、’f’、’g’、’h’八个字符，放入到buffer1
• 计算者从buffer1取出字符，将小写字符转换为大写字符，放入到buffer2
• 消费者从buffer2取出字符，将其打印到屏幕上

pc2.c: 使用信号量解决生产者、计算者、消费者问题

• 功能和前面的实验相同，使用信号量解决

条件变量

1.api

初始化条件变量

#include<pthread.h>
int pthread_cond_init(pthread_cond_t*cond,const pthread_condattr_t* attr);
int pthread_cond_destory(pthread_cond_t*cond);

等待条件变量满足

#include<pthread.h>
int pthread_cond_wait(pthread_cond_t* cond,pthread_mutex_t* mutex);

通知条件变量满足

#include<pthread.h>
int pthread_cond_signal(pthread_cond_t* cond);

2.使用

注:所谓的条件变量并没有控制所谓的条件,一般需要我们在外围增加判断条件.所以,条件变量一般的使用方式是:
->最原始

///////#thread1
if(条件不满足){
    pthread_cond_wait(&cond,&mutex);
}

/////#thread2
pthread_cond_signal(&cond)

说明:上述只是最简单的条件变量的实现方式.其中会造成的问题就是:如果程序中运行着多个线程1,那么在if语句判断结束之后,在wait函数执行之前.被中断,而在中断线程中改变条件,使得条件满足,再次切换到thread1中的时候,由于程序已经执行过判断条件.就会出现前后不一致的问题!所以我们需要增加一个互斥量,保护条件中涉及到的变量的安全,也就是保证线程安全!这也就是为什么条件变量要与互斥量共用的原因.
->修改1:

pthread_mutex_t mutex;
pthread_cond_t cond;

#thread1
pthread_mutex_lock(&mutex);
if(条件不满足){
    pthread_cond_wait(&cond,&mutex);
}
pthread_mutex_unlock(&mutex);

/#thread2
pthread_cond_signal(&cond)

运行过程:thread1获得mutex锁->thread1判断条件不满足->thread1调用cond_wait函数(线程挂起+释放mutex锁)->thread2调用signal(唤醒所有的被该条件变量阻塞的进程)->执行结束.
虽然看起来好像已经可以啦,但是还有一个问题没有解决就是使用while还是if的问题.关于这个问题.可以参考下面这篇博客
->修改2

pthread_mutex_t mutex;
pthread_cond_t cond;

#thread1
pthread_mutex_lock(&mutex);
while(条件不满足){
    pthread_cond_wait(&cond,&mutex);
}
pthread_mutex_unlock(&mutex);

/#thread2
pthread_cond_signal(&cond)

pc1.c: 使用条件变量解决生产者、计算者、消费者问题

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

//变量储存区
char buff1[5];
char buff2[5];
int index_buff1 = 0;
int index_buff2 = 0;

pthread_mutex_t buff1_mutex;
pthread_mutex_t buff2_mutex;
pthread_cond_t buff1_empty_cond;
pthread_cond_t buff1_full_cond;
pthread_cond_t buff2_empty_cond;
pthread_cond_t buff2_full_cond;

void init_mutex(){
    pthread_mutex_init(&buff1_mutex,NULL);
    pthread_mutex_init(&buff2_mutex,NULL);
    pthread_cond_init(&buff1_empty_cond,NULL);
    pthread_cond_init(&buff1_full_cond,NULL);
    pthread_cond_init(&buff2_empty_cond,NULL);
    pthread_cond_init(&buff2_full_cond,NULL);
}

void destory_mutex(){
    pthread_mutex_destroy(&buff1_mutex);
    pthread_mutex_destroy(&buff2_mutex);
    pthread_cond_destroy(&buff1_empty_cond);
    pthread_cond_destroy(&buff1_full_cond);
    pthread_cond_destroy(&buff2_empty_cond);
    pthread_cond_destroy(&buff2_full_cond);
}
void *producer(void *arg){

    int index;
    for(index=0;index<8;index++){
        pthread_mutex_lock(&buff1_mutex);
        while(index_buff1>=4){
            pthread_cond_wait(&buff1_empty_cond,&buff1_mutex);
        }
        buff1[index_buff1] = index+'a';
        printf("1--------\n");
        index_buff1++;
        pthread_cond_signal(&buff1_full_cond);
        pthread_mutex_unlock(&buff1_mutex);
    }
    return (void*)0;
}

void *lowToUp(void *arg){

    int index;
    for(index=0;index<8;index++){
        pthread_mutex_lock(&buff1_mutex);
        pthread_mutex_lock(&buff2_mutex);
        while(index_buff1<1){
            pthread_cond_wait(&buff1_full_cond,&buff1_mutex);
        }
        while(index_buff2>=4){
            pthread_cond_wait(&buff2_empty_cond,&buff2_mutex);
        }
        printf("2--------\n");
        index_buff1--;
        buff2[index_buff2] = buff1[index_buff1]-32;
        index_buff2++;
        pthread_cond_signal(&buff1_empty_cond);
        pthread_cond_signal(&buff2_full_cond);      
        pthread_mutex_unlock(&buff2_mutex);
        pthread_mutex_unlock(&buff1_mutex);
    }
    return (void*)0;
}

void *consume(void *arg){
    int index;
    for(index=0;index<8;index++){
        pthread_mutex_lock(&buff2_mutex);
        while(index_buff2<1){
            pthread_cond_wait(&buff2_full_cond,&buff2_mutex);
        }
        index_buff2--;
        printf("3--------%c\n",buff2[index_buff2]);
        pthread_cond_signal(&buff2_empty_cond);
        pthread_mutex_unlock(&buff2_mutex);
    }
    return (void*)0;
}

int main(){
    init_mutex();
    pthread_t produce_thread;
    pthread_t calc_thread;
    pthread_t consume_thread;
    pthread_create(&produce_thread,NULL,producer,NULL);
    pthread_create(&calc_thread,NULL,lowToUp,NULL); 
    pthread_create(&consume_thread,NULL,consume,NULL);

    pthread_join(produce_thread,NULL);
    pthread_join(calc_thread,NULL);
    pthread_join(consume_thread,NULL);
    destory_mutex();
    return 0;
}

信号量

信号量机制就是传统的pv操作.当资源不足的时候等待,当资源充足的时候,等待系统的线程调度.不存在上述条件变量所谓的通知.下面直接贴代码,很简单.

#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<pthread.h>
#include<semaphore.h>

//储存变量
char buff1[5];
char buff2[5];
int index_buff1 = 0;
int index_buff2 = 0;

//定义两个buff的互斥信号量
sem_t buff1_mutex;
sem_t buff2_mutex;
//定义进程内的互斥信号量
sem_t buff1_full;
sem_t buff1_empty;
sem_t buff2_full;
sem_t buff2_empty;

void init_mutex(){
    sem_init(&buff1_mutex,0,1);
    sem_init(&buff2_mutex,0,1);
    sem_init(&buff1_full,0,0);
    sem_init(&buff1_empty,0,4);
    sem_init(&buff2_full,0,0);
    sem_init(&buff2_empty,0,4);
}
void destroy_mutex(){
    sem_destroy(&buff1_mutex);
    sem_destroy(&buff2_mutex);
    sem_destroy(&buff1_full);
    sem_destroy(&buff1_empty);
    sem_destroy(&buff2_full);
    sem_destroy(&buff2_empty);
}


void *producer(void *arg){

    printf("hello world\n");
    int index;
    for(index=0;index<8;index++){
        //printf("%d\n",index);
        sem_wait(&buff1_empty);
        sem_wait(&buff1_mutex);
        buff1[index_buff1] = index+'a';
        //printf("%c\n",buff1[index_buff1]);
        //printf("1--------%c--%d\n",buff1[index_buff1],index_buff1);
        //index_buff2--;
        index_buff1++; 
        sem_post(&buff1_mutex);
        sem_post(&buff1_full);
    }
    return (void*)0;

}

void *lowToUp(void *arg){
    int index;
    for(index=0;index<8;index++){
        sem_wait(&buff1_full);
        sem_wait(&buff2_empty);
        sem_wait(&buff1_mutex);
        sem_wait(&buff2_mutex);
        index_buff1--;
        buff2[index_buff2] = buff1[index_buff1]-32;
        //printf("2-------%c--%d\n",buff2[index_buff2],index_buff2);
        index_buff2++;
        sem_post(&buff2_mutex);
        sem_post(&buff1_mutex);
        sem_post(&buff2_full);
        sem_post(&buff1_empty);
    }
    return (void*)0;
}
void *consume(void *arg){
    int index;
    for(index=0;index<8;index++){
        sem_wait(&buff2_full);
        sem_wait(&buff2_mutex);
        index_buff2--;
        printf("3--------%c \n",buff2[index_buff2]);
        sem_post(&buff2_mutex);
        sem_post(&buff2_empty);
    }
    return (void*)0;
}


int main(){
    pthread_t produce_thread;
    pthread_t calc_thread;
    pthread_t consume_thread;
    printf("hello wrold");
    //初始化所有的信号量
    init_mutex();
    printf("hello wrold\n");

    pthread_create(&produce_thread,NULL,producer,NULL);
    pthread_create(&calc_thread,NULL,lowToUp,NULL);

    pthread_create(&consume_thread,NULL,consume,NULL);
    pthread_join(produce_thread,NULL);
    pthread_join(calc_thread,NULL);
    pthread_join(consume_thread,NULL);
    destroy_mutex();
    return 0;
}