IOday6作业

使用有名管道，完成两个进程的相互通信

半双工相互通信
#include<myhead.h>

//发送方线程
void* task1(void* arg){
    //创建管道文件
    if((mkfifo("myfifo",0664)) == -1){
        perror("mkfile error");
    }

    //打开管道描述符
    int wfd=-1;
    if((wfd=open("myfifo",O_WRONLY))==-1){
        perror("open write");
    }

    printf("输入quit为退出会话\n");

    char wbuf[128]="";
    while(1){
        printf("请输入您要发送的信息：\n");
        fgets(wbuf,sizeof(wbuf),stdin);
        wbuf[strlen(wbuf)-1]=0;

        write(wfd,wbuf,sizeof(wbuf));
        if(strcmp(wbuf,"quit")==0)
        {
            break;
        }
    }
    close(wfd);
    system("rm myfifo");

    pthread_exit(NULL);
}

//接收方线程
void* task2(void* arg){
    int rfd=-1;
    if((rfd=open("myfifo",O_RDONLY))==-1){
        perror("read error");
    }

    char rbuf[128]="";
    while(1){
        memset(rbuf,0,sizeof(rbuf));
        read(rfd,rbuf,sizeof(rbuf));
        printf("您收到一条信息:%s\n",rbuf);
        if(strcmp(rbuf,"quit")==0){
            break;
        }
    }
    close(rfd);
    pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
    //定义两个线程
    pthread_t tid1,tid2;
    int flag;
    while(1)
    {
        printf("------------------会话只能由发送方发起与结束--------------\n");
        printf("-----------------------选择1：发送信息-------------------\n");
        printf("-----------------------选择2：接收信息-------------------\n");
        printf("-------------------------选择0：退出---------------------\n");
        scanf("%d",&flag);
        switch(flag)
        {
            case 1:
                //线程一
                if((pthread_create(&tid1,NULL,task1,NULL)) !=0)
                {
                    printf("tid1 create error\n");
                    return -1;
                }
                pthread_join(tid1,NULL);
                break;
            case 2:
                //线程二
                if((pthread_create(&tid2,NULL,task2,NULL)) !=0)
                {
                    printf("tid1 create error\n");
                    return -1;
                }
                pthread_join(tid2,NULL);
                break;
            case 0:
                goto END;
        }
        printf("输入'#'字符结束，否则继续\n");
        char element;
        element=getchar();
        if(element == '#')break;
    }
END:
    return 0;
}   

将互斥锁的案例重新写一遍

#include<myhead.h>

pthread_mutex_t mutex;
int money=5000;

void* task(void * arg){
    while(1){
    pthread_mutex_lock(&mutex);
    money-=100;
    printf("task线程剩余MONEY:%d\n",money);
    pthread_mutex_unlock(&mutex);
    sleep(1);
    }   
    pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
    pthread_mutex_init(&mutex,NULL);
    pthread_t tid;
    if(pthread_create(&tid,NULL,task,NULL)==-1){
        perror("pthread_create");
        return -1;
    }   
    while(1){
        pthread_mutex_lock(&mutex);
        money-=100;
        printf("主线程剩余MONEY:%d\n",money);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }   
        pthread_join(tid,NULL);
        pthread_mutex_destroy(&mutex);
    return 0;
}  

将无名信号量实现生产者消费者程序重新实现一遍

#include<myhead.h>
sem_t sem;

void* task(void* arg){
    while(1){
    printf("生产了一辆车\n");
    sem_post(&sem);
    sleep(1);
    }   
    pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
    sem_init(&sem,0,0);
    pthread_t tid;
    if(pthread_create(&tid,NULL,task,NULL)){
        perror("pthread_create");
        return -1; 
    }   
    
    while(1){
        sem_wait(&sem);
        printf("消费了一辆车\n");
        sleep(1);
    }   

    sem_destroy(&sem);
    pthread_join(tid,NULL);
    return 0;
}                                                                                                         
~ 

将条件变量实现生产者消费者程序重新实现一遍

#include<myhead.h>

pthread_mutex_t mutex;
pthread_cond_t cond;

void* task(){
    int n=5;
    while(n--){
    sleep(1);
    printf("生产了一辆车\n");
    pthread_cond_signal(&cond);
    }
    pthread_exit(NULL);
}

void* task2(){

    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond,&mutex);
    pthread_mutex_unlock(&mutex);
    printf("消费了一辆车\n");
    pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
    pthread_t tid1,tid2,tid3,tid4,tid5,tid6;
    
    if(pthread_create(&tid1,NULL,task,NULL)){
        perror("tid1");
        return -1;
    }

    if(pthread_create(&tid2,NULL,task2,NULL)){
        perror("tid2");
        return -1;
    }

    if(pthread_create(&tid3,NULL,task2,NULL)){
        perror("tid3");
        return -1;
    }

    if(pthread_create(&tid4,NULL,task2,NULL)){
        perror("tid4");
        return -1;
    }

    if(pthread_create(&tid5,NULL,task2,NULL)){
        perror("tid5");
        return -1;
    }
    if(pthread_create(&tid6,NULL,task2,NULL)){
        perror("tid6");
        return -1;
    }
    
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    pthread_join(tid4,NULL);
    pthread_join(tid5,NULL);
    return 0;
}  

两个线程实现文件拷贝

#include<myhead.h>

typedef struct argin{
    char *src;
    char *des1;
    char *des2;
    int len;
}Info;

int get_file_len(const char *src){
    int srcfd;
    if((srcfd=open(src,O_RDONLY,0664))==-1){
        perror("open error");
        return -1;
    }

    int len=lseek(srcfd,0,SEEK_END);
    close(srcfd);
    return len;
}

int file_cpy(const char *srcfile,const char* desfile,int start,int len){
    int srcfd;
    if((srcfd=open(srcfile,O_RDONLY,0664))==-1){
        perror("open src error");
        return -1;
    }

    int desfd;
    if((desfd=open(desfile,O_RDWR|O_CREAT|O_TRUNC,0664))==-1){
        perror("open des error");
        return -1;
    }

    lseek(srcfd,start,SEEK_SET);
    char element;
    for(int i=0;i<len;i++){
        read(srcfd,&element,1);
        write(desfd,&element,1);
    }
    close(srcfd);
    close(desfd);
    return 0;
}


void* task1(void* arg){
    Info eg=*(Info*)arg;
    int len=eg.len;

    file_cpy(eg.src,eg.des1,0,len/2);
    printf("线程1拷贝完成\n");
    pthread_exit(NULL);
}

void* task2(void* arg){
    Info eg=*(Info*)arg;
    int len=eg.len;

    file_cpy(eg.src,eg.des2,len/2,len-len/2);
    printf("线程2拷贝完成\n");
    pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
    int len=get_file_len(argv[1]);

    Info eg={argv[1],argv[2],argv[3],len};

    pthread_t tid1=-1;
    if(pthread_create(&tid1,NULL,task1,(void*)&eg)!=0){
        printf("create pthread 1 error\n");
        return -1;
    }

    pthread_t tid2=-1;
    if(pthread_create(&tid2,NULL,task2,(void*)&eg)!=0){
        printf("create pthread 1 error\n");
        return -1;
    }

    pthread_join(tid1,NULL);
    printf("线程1已经回收\n");
    pthread_join(tid2,NULL);
    printf("线程2已经回收\n");

    return 0;
}