嵌入式学习--IO进程线程

一级目录

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
//临界资源（共享资源）
int flag=0;//读取未结束
//信号量sem_t sem1;
sem_t sem2;
struct info
{
    int fd;
    char s;
};                                                                  

void* callBack_print(void* arg)
{
    struct info *ar=(struct info*)arg;
    while(1)
    {
        /***临界区*****/
        sem_wait(&sem1);    //P操作
        if(flag==1)break;

        fprintf(stdout,"%c", ar->s);

        sem_post(&sem2);    //V操作

        /***临界区*****/
    }
    pthread_exit(NULL);
}

void* callBack_read(void* arg)
{

    struct info *ar=(struct info*)arg;
    while(1)
    {
        /***临界区*****/
        sem_wait(&sem2);    //P操作

        if(read(ar->fd,&(ar->s),1)<=0)
        {
            flag=1;//读取结束;
        sem_post(&sem1);    //V操作

            break;
        }
        sem_post(&sem1);    //V操作

        /***临界区*****/
    }
    pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
    //创建并初始化信号量始
    if(sem_init(&sem1, 0, 0) < 0)
    {
        perror("sem_initi1");
        return -1;
    }
    printf("sem1 init success\n");

    if(sem_init(&sem2, 0, 1) < 0)
    {
        perror("sem_init2");
        return -1;
    }
    printf("sem2 init success\n");

    int fd=open("./2test.c",O_RDONLY);
    struct info ss;
    ss.fd=fd;
    char c=0;
    ss.s=c;
    pthread_t tid1, tid2;
    //创建一个线程，打印
    if(pthread_create(&tid1, NULL, callBack_print, (void*)&ss) != 0)
    {
        perror("pthread_create");
        return -1;
    }

    //创建一个线程，读取
    if(pthread_create(&tid2, NULL, callBack_read, (void*)&ss) != 0)
    {
        perror("pthread_create");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    sem_destroy(&sem1);
    sem_destroy(&sem2);

    return 0;
}

result

条件变量+互斥锁

#include<stdio.h>                               
#include<pthread.h>
#include<unistd.h>
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
int flag=0;int flag_quit=0;
pthread_cond_t cond1;
pthread_cond_t cond2=PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3=PTHREAD_COND_INITIALIZER;
void *callback1(void *arg)
{
    int i=0;
    while(1)
    {
        i++;if(i>5){flag_quit=1;break;}
        pthread_mutex_lock(&mutex);
        if(flag!=0)
        {
        pthread_cond_wait(&cond1,&mutex);
        }

        fprintf(stdout,"A");
        fflush(stdout);
        flag=1;
        sleep(0.1);
        pthread_cond_signal(&cond2);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}
void *callback2(void *arg)
{
    while(1)
    {
        if(flag_quit==1)break;

        pthread_mutex_lock(&mutex);;

        if(flag!=1)
        {
            pthread_cond_wait(&cond2,&mutex);
        }
        fprintf(stdout,"B");fflush(stdout);
        flag=2;
        sleep(0.1);
        pthread_cond_signal(&cond3);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}
void *callback3(void *arg)
{   
    while(1)
    {
        if(flag_quit==1)break;
        pthread_mutex_lock(&mutex);
        if(flag!=2)
        {
        pthread_cond_wait(&cond3,&mutex);
        }

        printf("C\n");
        sleep(0.1);
        flag=0;
        pthread_cond_signal(&cond1);
        pthread_mutex_unlock(&mutex);
    }   
    pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{   
    pthread_cond_init(&cond1,NULL);
    
    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    
    pthread_create(&tid1,NULL,callback1,NULL);
    pthread_create(&tid2,NULL,callback2,NULL);
    pthread_create(&tid3,NULL,callback3,NULL);
    
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond1);
    pthread_cond_destroy(&cond2);
    pthread_cond_destroy(&cond3);
    return 0;
}

result