LINUX操作系统实验 两个进程相互通信

于 2024-12-06 19:17:08 发布
阅读量1.4k 收藏 31
点赞数 32
文章标签： linux 服务器 ubuntu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rabbit__7/article/details/144298471
版权

1、编写C程序，使用Linux中的IPC机制，完成 “石头、剪子、布”的游戏。

决定写这篇是因为在网上都搜不到第二部分的实验内容，自己学会了之后决定写了这个实验的流程

第一部分使用的msgp代码，放了些其他类型的代码可以参考

msgq代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct Game   //游戏信息
{
    long Type;
    int Round;

};
void result_send(int num)     //发送出拳信息
{
    struct Game game;
    game.Type = 1;
    game.Round = rand() % 3;
    msgsnd(num, &game, sizeof(int), 0);
}
int result_announce(int a, int b)    //出拳结果的判断
{
    if ((a + 1 == b) || (a - 3 == b))
        return -1;    //a胜b
    else if (a == b)
        return 0;    //ab平局
    else
        return 1;    //a负b
}
void writeFile(int *result_list, int len)   //将每盘的结果存入文件
{
    int count_A = 0; 
    int count_B = 0;
    int pingju=0;
    FILE *fin;
    if( (fin = fopen( "result.txt", "w" )) == NULL ) 
        printf( "This file wasn't opened" );

    int i;
    for (i = 0; i < len ; i++)
    {
        switch(result_list[i])
        {
            case -1 :{
                count_A++;
                fprintf(fin, "NO.%d:A win\n", i + 1);
                printf("NO.%d:A win\n", i + 1);
                break;
            }
            case 0 : {
                pingju++;
                fprintf(fin, "NO.%d:end in a draw\n", i + 1);
                printf("NO.%d:end in a draw\n", i + 1);
                break;
            }
            case 1 : {
                count_B++;
                fprintf(fin, "NO.%d:B win\n", i + 1);
                printf("NO.%d:B win\n", i + 1);
                break;
            }
        }
    }

    printf("\nThe final result is A win:%ds \nB win:%ds \nend in a draw %ds\n",count_A,count_B,pingju);
    fprintf(fin, "\nThe final result is A win:%ds \nB win:%ds \nend in a draw %ds\n",count_A,count_B,pingju);
    fclose(fin);
}
int main()
{
    int times; 
    int key1 = 1234;
    int key2 = 5678;
    int *result_list;
    pid_t  pid1, pid2;  
    int msgid1,msgid2;
    msgid1 = msgget(key1, IPC_CREAT | 0666); //创建消息队列
    if(msgid1 == -1)
    {
        fprintf(stderr, "failed with error");
        exit(EXIT_FAILURE);
    }
    msgid2 = msgget(key2, IPC_CREAT | 0666); //创建消息队列
    if(msgid2 == -1)
    {
        fprintf(stderr, "failed with error");
        exit(EXIT_FAILURE);
    }
    printf("Game start,please input rounds:");
    scanf("%d", &times);
    result_list=(int*)malloc(times*sizeof(int));
    int i;
    for (i = 0; i < times; i++)
    {
        pid1 = fork();   //创建选手1
        if (pid1 == 0) 
        {
            srand((unsigned)time(0) * 3000 ); //以时间为种子
            result_send(msgid1);  //生成选手1的出拳信息并发送到信息队列
            exit(-1);
        }
        pid2 = fork();   //创建选手2
        if (pid2 == 0) 
        {
            srand((unsigned)time(NULL)*i ); //以时间为种子
            result_send(msgid2);  //生成选手2的出拳信息并发送到信息队列
            exit(-1);
        }

        if (pid1 < 0 || pid2 < 0)
        {
            fprintf(stderr, "Fork Failed");
            exit(-1);
        }
        else
        {
            wait(NULL);
            wait(NULL);
            struct Game game1;
            struct Game game2;
//printf("wait ok.\n");
       //从消息队列中取得选手1的出拳信息
            msgrcv(msgid1, &game1, sizeof(game1) - sizeof(long), 0, 0);
//printf("rcv1 ok.\n");
        //从消息队列中取得选手2的出拳信息
            msgrcv(msgid2, &game2, sizeof(game2) - sizeof(long), 0, 0); 
        //评判出拳结果
//printf("rcv2 ok.\n");
            int j = result_announce(game1.Round, game2.Round);
            //result_list[i] = result_announce(game1.Round, game2.Round); 
            result_list[i] = j;
        }
    }
//printf("end ok.\n");
    //将比赛结果写入文件
    writeFile(result_list, times);
    //删除消息队列
/*    if (msgctl(msgid1, IPC_RMID, 0) == -1)
    {
        fprintf(stderr, "msgctl(IPC_RMID) failed\n");
    }
    if (msgctl(msgid2, IPC_RMID, 0) == -1)
    {
        fprintf(stderr, "msgctl(IPC_RMID) failed\n");
    }
 */   exit(EXIT_SUCCESS);
}

pipe代码：

#include <unistd.h>  
#include <sys/types.h>  
#include <errno.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h> 
#include<time.h>

#define MAX_DATA_LEN   256  
#define DELAY_TIME 1  

/*
数据结构
0：石头
1：剪刀
2：布*/

/*judge函数返回值含义
1：甲赢
0：平局
-1：乙赢*/

int judge(char a,char b)   //胜负判定函数
{
    if(a==b)
        return 0;
    else
    {
        if(a=='0'&&b =='1')
            return 1;
        if(a=='0'&&b =='2')
            return -1;
        if(a=='1'&&b =='2')
            return 1;
        if(a=='1'&&b =='0')
            return -1;
        if(a=='2'&&b =='0')
            return 1;
        if(a=='2'&&b =='1')
            return -1;
    }
}


int main()  
{     
    /*创建第一个管道和第一个子进程*/
     pid_t pid;     
      
     int pipe_fd[2];    
     char buf[MAX_DATA_LEN];    
     char data[20];   
     int real_read, real_write;   //管道的读写操作
     
     memset((void*)buf, 0, sizeof(buf));   //清空缓冲区  
   
     if (pipe(pipe_fd) < 0)   //判断管道是否创建成功 
     {         
         printf("pipe create error\n");       
         exit(1);    
     }  
         
    if ((pid = fork()) == 0)     //创建第一个子进程
     {
     
         close(pipe_fd[0]);      // 子进程关闭读描述符      
         sleep(3);               //通过使子进程暂停3s等待父进程已关闭相应的写描述符  
                    
          //子进程在管道中写内容      
         srand(time(NULL));
         int i;
         for(i = 0;i<120;i++)
         {
             sprintf(data,"%d",rand()%3);//随机产生0-2的数字写入管道
             while(write(pipe_fd[1],data,strlen(data))==-1);//不断尝试写直到成功
         }   
  
         close(pipe_fd[1]);          
         exit(0);      
 }
 
   /*创建第二个管道和第二个子进程*/
     pid_t pid_1;    
       
     int pipe_fd_1[2];    
     char buf_1[MAX_DATA_LEN];    
     char data_1[20];   
     int real_read_1, real_write_1;
     
     memset((void*)buf, 0, sizeof(buf));   //清空缓冲区  
   
     if (pipe(pipe_fd_1) < 0)   //判断管道是否创建成功 
     {         
         printf("pipe create error\n");       
         exit(1);    
     }  
         
    if ((pid_1 = fork()) == 0)     //创建第一个子进程
     {
     
         close(pipe_fd_1[0]);      // 子进程关闭读描述符      
         sleep(3);               //通过使子进程暂停3s等待父进程已关闭相应的写描述符  
                    
          //子进程在管道中写内容      
         srand(time(NULL)+120);
         int i;
         for(i = 0;i<120;i++)
         {
             sprintf(data_1,"%d",rand()%3);//随机产生0-2的数字写入管道
             while(write(pipe_fd_1[1],data_1,strlen(data_1))==-1);//不断尝试写直到成功
         }   
  
         close(pipe_fd_1[1]);    //关闭子进程写描述符      
         exit(0);      
 }
 
   
         /*父进程*/
     else if (pid > 0)     
      {         
           /* 读取第一个管道的数据 */             
         close(pipe_fd[1]);      //父进程关闭写描述符      
         sleep(1);      //通过使父进程暂停1s等待子进程关闭相应的读描述符
               
         if((real_read = read(pipe_fd[0], buf, MAX_DATA_LEN)) > 0)     
           {          
             printf("读取选手甲数据成功！\n");  
           }     
                  
         close(pipe_fd[0]);     //关闭父进程读描述符   
         waitpid(pid, NULL, 0);  //收集子进程1退出信息
         
          /* 读取第二个管道的数据 */             
         close(pipe_fd_1[1]);      //父进程关闭写描述符      
         sleep(1);      //通过使父进程暂停1s等待子进程关闭相应的读描述符
               
         if((real_read_1 = read(pipe_fd_1[0], buf_1, MAX_DATA_LEN)) > 0)     
           {          
             printf("读取选手乙数据成功！\n\n");  
           }     
                  
         close(pipe_fd_1[0]);     //关闭父进程读描述符   
         waitpid(pid_1, NULL, 0);  //收集子进程2退出信息
           /*结束*/
         
           //判定比赛并公示结果
          int aw = 0,bw = 0,n_w = 0;
          int res = 0;
          int i;
          for(i = 0;i<120;i++){
              printf("第%d回合：",i+1);
              res = judge(buf[i],buf_1[i]);

              if(res == 1){
                  printf("甲赢！\n");
                  aw++;
                  }
              else if(res == -1){
                  printf("乙赢！\n");
                  bw++;
                  }
              else{
                  printf("平局！\n");
                  n_w++;
                  }
             }
             
          printf("\n比赛结果公示\n");
          printf("选手甲赢了：%d次\n",aw);
          printf("选手乙赢了：%d次\n",bw);
          printf("平局：%d次\n",n_w);
          exit(0);
       }   
          
             
     return 0;   
}
 

shm代码：

a:

#include<stdio.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<string.h>
#include<time.h>
#include<sys/sem.h>

typedef struct _test{
    int a_val;
    int b_val;
    int a_flag;
    int b_flag;
    int game_no;
    int stage;
}test;

void sem_p();
void sem_v();
void set_sem();
void del_sem();
int sem_id;

union semun{
    int val;
    struct semid_ds *buf;
    unsigned short *arry;
};

int pk[3][3] = {0,-1,1,1,0,-1,-1,1,0};
int other[3][3] = {0,2,1,1,0,2,2,1,0};
int you;
int arr[3];

int main(){
    srand((int)time(0));
    int shmid;
    test* shm;
    
    shmid = shmget((key_t)1236,sizeof(test),0666);    
    if(shmid == -1){
        printf("shmget failed\n");
        exit(EXIT_FAILURE);
    }
    printf("%d",shmid);

    shm = shmat(shmid,0,0);
    if (shm == (void*)-1){
        printf("shmat failed\n");
        exit(EXIT_FAILURE);
    }
    printf("\nMemory attached at %X\n",(int)shm);
    
    sem_id = semget((key_t)3000,1,0666|IPC_CREAT);

    int no=0;
    while(1){
        sem_p();
        if(shm->game_no==-1){
            sem_v();
            break;
        }
        if (shm->stage==0){
            if(no!=shm->game_no){
                no = shm->game_no;
                printf("-------------------\n");
                printf("game_no:%d\n",no);
            }
            if(shm->a_flag==0){
                shm->a_flag=1;
                shm->a_val = rand()%3;
                printf("you:%d\n",shm->a_val);
                you = shm->a_val;
            }
        }
        else if(shm->stage==1){
        
        }
        else if(shm->stage==2){
            if(shm->a_flag==0){
                shm->a_flag=1;
                int val=shm->a_val;
                printf("other:%d\n",other[you][(val==-1)?2:val]);
                if(val==0) {arr[0]++; printf("draw!\n");}
                if(val==1) {arr[1]++; printf("you win!\n");}
                if(val==-1){arr[2]++; printf("you lost!\n");}
                printf("-------------------\n");
            }
        }
        sem_v();
    }
    
    printf("draw:%d\nwin:%d\nlost:%d\n",arr[0],arr[1],arr[2]);    

    shmdt(shm);

}
void set_sem(){
    union semun sem_union;
    sem_union.val=1;
    semctl(sem_id,0,SETVAL,sem_union);
}

void del_sem(){
    union semun sem_union;
    semctl(sem_id,0,IPC_RMID,sem_union);
}

void sem_p(){
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = -1;
    sem_b.sem_flg = SEM_UNDO;
    semop(sem_id,&sem_b,1);
}

void sem_v(){
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = 1;
    sem_b.sem_flg = SEM_UNDO;
    semop(sem_id,&sem_b,1);
}
 

b:

#include<stdio.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<string.h>
#include<time.h>
#include<sys/sem.h>

typedef struct _test{
    int a_val;
    int b_val;
    int a_flag;
    int b_flag;
    int game_no;
    int stage;
}test;

void sem_p();
void sem_v();
void set_sem();
void del_sem();
int sem_id;

union semun{
    int val;
    struct semid_ds *buf;
    unsigned short *arry;
};

int pk[3][3] = {0,-1,1,1,0,-1,-1,1,0};
int other[3][3] = {0,2,1,1,0,2,2,1,0};
int you;
int arr[3];

int main(){
    srand((int)time(0));
    int shmid;
    test* shm;
    
    shmid = shmget((key_t)1236,sizeof(test),0666);    
    if(shmid == -1){
        printf("shmget failed\n");
        exit(EXIT_FAILURE);
    }
    printf("%d",shmid);

    shm = shmat(shmid,0,0);
    if (shm == (void*)-1){
        printf("shmat failed\n");
        exit(EXIT_FAILURE);
    }
    printf("\nMemory attached at %X\n",(int)shm);
    
    sem_id = semget((key_t)3000,1,0666|IPC_CREAT);

    int no=0;
    while(1){
        sem_p();
        if(shm->game_no==-1){
            sem_v();
            break;
        }
        if (shm->stage==0){
            if(no!=shm->game_no){
                no = shm->game_no;
                printf("-------------------\n");
                printf("game_no:%d\n",no);
            }
            if(shm->b_flag==0){
                shm->b_flag=1;
                shm->b_val = rand()%3;
                printf("you:%d\n",shm->b_val);
                you = shm->b_val;
            }
        }
        else if(shm->stage==1){
        
        }
        else if(shm->stage==2){
            if(shm->b_flag==0){
                shm->b_flag=1;
                int val=shm->b_val;
                printf("other:%d\n",other[you][(val==-1)?2:val]);
                if(val==0) {arr[0]++; printf("draw!\n");}
                if(val==1) {arr[1]++; printf("you win!\n");}
                if(val==-1){arr[2]++; printf("you lost!\n");}
                printf("-------------------\n");
            }
        }
        sem_v();
    }
    
    printf("draw:%d\nwin:%d\nlost:%d\n",arr[0],arr[1],arr[2]);    

    shmdt(shm);

}
void set_sem(){
    union semun sem_union;
    sem_union.val=1;
    semctl(sem_id,0,SETVAL,sem_union);
}

void del_sem(){
    union semun sem_union;
    semctl(sem_id,0,IPC_RMID,sem_union);
}

void sem_p(){
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = -1;
    sem_b.sem_flg = SEM_UNDO;
    semop(sem_id,&sem_b,1);
}

void sem_v(){
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = 1;
    sem_b.sem_flg = SEM_UNDO;
    semop(sem_id,&sem_b,1);
}
 

test:

#include<stdio.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/sem.h>
#include<string.h>

typedef struct _test{
    int a_val;
    int b_val;
    int a_flag;
    int b_flag;
    int game_no;
    int stage;
}test;

int pk[3][3] = {0,-1,1,1,0,-1,-1,1,0};

void sem_p();
void sem_v();
void set_sem();
void del_sem();
int sem_id;

union semun{
    int val;
    struct semid_ds *buf;
    unsigned short *arry;
};

int main(){
    int shmid;
    test* shm;
    
    shmid = shmget((key_t)1236,sizeof(test),0666|IPC_CREAT);    
    if(shmid == -1){
        printf("shmget failed\n");
        exit(EXIT_FAILURE);
    }
    printf("%d",shmid);

    shm = shmat(shmid,0,0);
    if (shm == (void*)-1){
        printf("shmat failed\n");
        exit(EXIT_FAILURE);
    }
    printf("\nMemory attached at %X\n",(int)shm);

    sem_id = semget((key_t)3000,1,0666|IPC_CREAT);
    set_sem();

    int no=0,debug=0,a,b;
    shm->a_flag=0;    shm->a_val = -2;
    shm->b_flag=0;    shm->b_val = -2;
    shm->game_no=1;
    shm->stage=0;
    while(1){
        sem_p();
        //printf("a:%d b:%d\n",shm->a_val,shm->b_val); sleep(1);
        if(shm->game_no==-1){
            sem_v();
            break;
        }
        if (shm->stage==0){
            if(no!=shm->game_no){
                no = shm->game_no;
                printf("-------------------\n");
                printf("game_no:%d\n",no);
            }
            if(shm->a_flag==1 && shm->b_flag==1) shm->stage=1;
        }
        else if(shm->stage==1){
            printf("a:%d\n",shm->a_val);
            printf("b:%d\n",shm->b_val);
            a = pk[shm->a_val][shm->b_val];
            b = pk[shm->b_val][shm->a_val];
            shm->a_val=a;
            shm->b_val=b;
            shm->a_flag=0;
            shm->b_flag=0;
            shm->stage=2;
        }
        else if(shm->stage==2){
            if(shm->a_flag==1 && shm->b_flag==1){
                shm->stage=0;
                shm->game_no++;
                shm->a_flag=0;
                shm->b_flag=0;
                printf("-------------------\n");
                if(shm->game_no > 100) shm->game_no=-1;
            }
        }
        sem_v();
    }

    shmdt(shm);

    int ret=0;
    ret = shmctl(shmid,IPC_RMID,NULL);
    if(ret<0){
        printf("shmctl error!\n");
    }

    del_sem();

    printf("finish");
}

void set_sem(){
    union semun sem_union;
    sem_union.val=1;
    semctl(sem_id,0,SETVAL,sem_union);
}

void del_sem(){
    union semun sem_union;
    semctl(sem_id,0,IPC_RMID,sem_union);
}

void sem_p(){
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = -1;
    sem_b.sem_flg = SEM_UNDO;
    semop(sem_id,&sem_b,1);
}

void sem_v(){
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = 1;
    sem_b.sem_flg = SEM_UNDO;
    semop(sem_id,&sem_b,1);
}
 

socket代码：

选手1：

#include<stdlib.h>
#include<time.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
 
int main()
{
  int sockfd1 =-1;
  char game1;
  int len = 0;
   struct sockaddr_in address;
  int result;
  char ch='A';
  srand((unsigned)time(NULL));
 

  sockfd1 = socket(AF_INET, SOCK_STREAM, 0);
  address.sin_family = AF_INET;
    address.sin_addr.s_addr = inet_addr("127.0.0.1");
    address.sin_port = htons(9736);
    len = sizeof(address);

  result = connect(sockfd1, (struct sockaddr*)&address, len);

  if(result == -1)
    {
        perror("ops:client\n");
        exit(1);
    }
  for (int i=0;i<=100;i++){
     game1=rand()%3+'0';
    write(sockfd1, &game1, 1);

    read(sockfd1, &ch, 1);
    printf("result form server = %c\n",ch);
    printf("game1 form server = %c\n",game1);}
    close(sockfd1);
    exit(0);
}
 

选手2：

#include<stdlib.h>
#include<time.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
 
int main()
{
  int sockfd2 =-1;
  char game2;
  int len = 0;
  char ch='A';
   struct sockaddr_in address;
  int result;
  srand((unsigned)time(NULL));


  sockfd2 = socket(AF_INET, SOCK_STREAM, 0);
  address.sin_family = AF_INET;//使用网络套接字
    address.sin_addr.s_addr = inet_addr("127.0.0.1");//服务器地址
    address.sin_port = htons(9736);//服务器所监听的端口
    len = sizeof(address);

  result = connect(sockfd2, (struct sockaddr*)&address, len);

  if(result == -1)
    {
        perror("ops:client\n");
        exit(1);
    }
    for (int i=0;i<=100;i++){
  game2=rand()%3+'0';
  write(sockfd2, &game2, 1);
    //从服务器获取数据
    read(sockfd2, &ch, 1);
    printf("result form server = %c\n", ch);
  printf("game2 form server = %c\n", game2);}
    close(sockfd2);
    exit(0);
}
 

裁判：

#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<signal.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
 {
     int server_sockfd = -1;
     int client_sockfd1 = -1;
    int client_sockfd2= -1;
     int client_len1 = 0;
     int client_len2 = 0;
     struct sockaddr_in server_addr;
     struct sockaddr_in client_addr1;
     struct sockaddr_in client_addr2;
     char game1;
     char game2;
     int count=0;
     int result;
     char ch='H';
     

     server_sockfd = socket(AF_INET,SOCK_STREAM,0);

     server_addr.sin_family = AF_INET;
     server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
     server_addr.sin_port = htons(9736);

     bind(server_sockfd,(struct sockaddr*)&server_addr,sizeof(server_addr));

     listen(server_sockfd, 100);

     signal(SIGCHLD, SIG_IGN);

   
         client_len1= sizeof(client_addr1);
         client_len2= sizeof(client_addr2);
         printf("Server waiting\n");

         client_sockfd1 =accept(server_sockfd,(struct sockaddr*)&client_addr1,&client_len1);
         client_sockfd2 =accept(server_sockfd,(struct sockaddr*)&client_addr2,&client_len2);
            for(int i=0;i<=100;i++)
            {
          
                read(client_sockfd2,&game2,1);
                read(client_sockfd1,&game1,1);
                
                sleep(3);
                if(game1==game2)
                {
                    ch='D';
                }
                if( (game1=='2'&&game2=='1')||(game1=='1'&&game2=='0')||(game1=='0'&&game2=='2'))
                {
                    ch='W';
                }
                if((game2=='2'&&game1=='1')||(game2=='1'&&game1=='0')||(game2=='0'&&game1=='2'))
                {
                    ch='L';
                }
                printf("game1:%c\n",game1);
                printf("game2:%c\n",game2);
                printf("%c\n",ch);
                write(client_sockfd1,&ch,1);
                write(client_sockfd2,&ch,1);
             } close(client_sockfd1);
                close(client_sockfd2);
                exit(0);
            
            /*else
            {
                /*close(client_sockfd1);
                close(client_sockfd2);
            }*/
            
 }

实验结果：

2、修改上述程序，使之能够在网络上运行该游戏。

这部分使用的代码是上面的socket代码，不再复制了

提示：要将代码中的端口和ip换成自己的，如何在控制台搜索能用的ip和端口自己去搜。

运行时要将裁判的代码先运行，出现server waiting说明是正确的，再重新打开控制台打开选手1的，再重新打开一个打开选手2的，等待一会就会出现结果

实验结果：

Rabbit__7
关注
实验四：Linux下进程管道通信.docx
04-13
操作系统实验四：Linux下进程管道通信 任务1：使用Pipe创建管道，创建一个子进程，子进程向父进程发送消息“I am your son!”,父进程接收到子进程的消息后，显示在屏幕上，并向子进程发送“I am your father!”。子进程接收到父进程的消息并显示在屏幕上。 任务2：使用系统调用 pipe ( ) 建立一条管道线；两个子进程 P1 和 P2 分别向管道各写一句话 Child 1 is sending a message! Child 2 is sending a message！ 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。 任务3：能否创建一条管道，实现两个子进程之间的通信，如果可以，请实现并给出代码。如果不可以，请说明理由
在Ubuntu linux C语言实现剪刀石头布
临风暖阳的博客
02-16 3830
0、1、2三个整数分别是剪刀石头布在程序中的内部表示，用户也要求输入0、1或2，然后和计算机随机生成的0、1或2比胜负。这个程序的主体是一个死循环，需要按Ctrl-C退出程序。以往我们写的程序都只有打印输出，在这个程序中我们第一次碰到处理用户输入的情况。在这里只是简单解释一下，以后再细讲。scanf("%d", &man)这个调用的功能是等待用户输入一个整数并回车，这个整数会被scanf函数保存在man这个整型变量里。如果用户输入合法（输入的确实是整数而不是字符串），则scanf函数返回1，表示成.
第3章：游戏：石头，剪刀，布
忆
12-26 1216
/** * 游戏：石头，剪刀，布。 * 程序提示用户随机产生一个数，这个数是0、1或2，分别表示石头、剪刀和布。 * 提示用户输入值0、1或2： * 显示一个消息，表明用户和计算机是谁赢了游戏，谁赢了游戏，或者是达成了平手。 */ package Test; import java.util.Scanner; public class T317Scanner { public st
命名管道实现进程间通信--石头、剪刀、布游戏 分类： linux ...
weixin_33672109的博客
06-01 4088
下面这个程序利用命名管道实现进程间通信，模拟石头剪刀布游戏。 主进程为裁判进程，两个子进程为选手进程。裁判与选手间各建立一个命名管道。 进行100次出招，最后给出游戏胜负。 #include <unistd.h> #include<fcntl.h> #include<stdio.h> #include<sys/types.h&gt...
操作系统 实验四 进程间通信实验
weixin_57836618的博客
11-26 8271
实验四 进程间通信实验 一、实验目的 1、了解什么是信号。 2、熟悉LINUX系统中进程之间软中断通信的基本原理。 3、理解进程的同步关系。 4、了解什么是管道。 5、熟悉UNIX/LINUX支持的管道通信方式。 二、实验内容 1、编写一段程序，使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进 程捕捉键盘上来的中断信号（即按ctrl+c键），当捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：...
linux进程间通信实现剪刀石头布-命名管道
qq_42997099的博客
11-13 7371
linux进程间通信实现剪刀石头布 为何要写这篇文章？ 因为本人在操作课程上需要写这么个东西，查阅网络资料，发现似乎只有一个源码！ 全网就那么一个源码，抄都没得抄。 https://blog.csdn.net/weixin_33672109/article/details/94240244 连接放在这里。 这段代码没有问题，可以正常运行，但可惜的是，他是一次性生成了100个随机数塞进管道里，随后再由裁判统一判定，这样显然不是真实的猜拳流程，人不可能虚空划拳。 老师也要求程序应当有“轮”的概念，在本人捣鼓了半
实验二、进程间通信
weixin_45788387的博客
10-17 1万+
实验二、进程间通信 实验环境： Linux 平台 实验时间： 6 小时 实验目的： 初步了解 Linux 系统中，进程间通信的方法。 实验目标： 编写一个程序，用 Linux 中的 IPC 机制，完成两个进程“石头、剪子、布”的 游戏 实验步骤： 本实验可以创建三个进程，其中，一个进程为裁判进程，另外两个进程为选 手进程。可以将“石头、剪子、布”这三招定义为三个整型值。胜负关系：石头〉 剪子〉布〉石头。 选手进程按照某种策略（例如，随机产生）出招，交给裁判进程判断大小。 裁判进程将对手的出招和胜负结果通知选
Linux下C编程 进程通信 (IPC)
iamhycljc的专栏
10-05 1430
本文转自：http://www.cppblog.com/bigsml/archive/2009/03/04/10847.html 在Linux中存在下面几种进程间通信方式: 1.POSIX无名信号量 2.System V信号量 3.System V消息队列 4.S
操作系统实验四 进程的管道通信 实验报告
10-23
总结起来，这个实验加深了对操作系统中进程通信的理解，尤其是管道通信的概念。通过实践，我们学习了如何创建管道、读写管道以及如何在父子进程中协调通信。这对于理解和开发多进程应用程序，特别是在需要进程间数据...
电子科大操作系统实验课Linux通过管道实现进程间通信
01-05
- 管道是Linux操作系统中的一种简单但有效的进程间通信(IPC, Inter-Process Communication)机制，它允许一个进程的输出作为另一个进程的输入。 - 在这个实验中，通过`pipe()`系统调用创建了一个单向的数据通道，...
实验5--Linux-高级程序设计.doc
06-20
实验5 Linux 高级程序设计 1、实验目的 (1)了解Linux操作系统下应用程序开发流程 (2)掌握gun工具链的使用 (3)了解Linux高级编程技巧（例如IPC机制、系统调用等） 2、实验内容 1. 编写一个简单的C语言程序，编写Makefile文件。了解编译过程，并用gdb进行调 试。 （2） 编写一个多线程程序(pthread)，实现2程同步互斥 #include <stdio.h> #include <pthread.h> #define BUFFER_SIZE 16 struct prodcons { // 缓冲区相关数据结构 int buffer[BUFFER_SIZE]; pthread_mutex_t lock; int readpos, writepos; pthread_cond_t notempty; pthread_cond_t notfull; }; void init(struct prodcons *b) { pthread_mutex_init(&b->lock, NULL); pthread_cond_init(&b->notempty, NU
Linux下的石头剪刀布游戏
04-08
这是一个在Linux下的多进程程序，网上没有哦！
计算机操作系统实验-进程通信（一）.doc
08-21
计算机操作系统实验-进程通信（一） 本实验的目的是学习如何利用管道机制和共享存储区机制进行进程间的通信，并加深对上述通信机制的理解。在实验中，我们将学习如何使用系统调用 pipe()、shmget()、shmat()、shmdt...
操作系统Linux实验报告三：进程管理及进程通信.doc
07-13
本实验报告主要关注于Linux操作系统中的进程管理和进程通信，通过一系列实验和实践，旨在加深对进程概念的理解，体会系统进程调度的方法和效果，并了解进程之间的通信方式。 一、进程管理 在Linux操作系统中，进程...
实现两个进程之间的双向通信
lc的博客
12-03 315
两进程之间的双向通信
江西师范大学 操作系统 实验 使用Linux中的IPC机制，完成 “石头、剪子、布”的游戏。
热门推荐
万伏小太阳
03-19 1万+
进程通信石头剪刀布 裁判进程 #include<stdio.h> #include<sys/types.h> #include<sys/ipc.h> #include<sys/msg.h> #include<stdlib.h> #include<string.h> struct msgbuf { //消息缓冲区，具体看 play_01.c long ms
【操作系统】进程的控制和通信
Python、C++、HTML、Java
10-29 1584
【实验内容】（1）编写一个C程序，并使用系统调用fork()创建一个子进程。要求如下： ① 在子进程中分别输出当前进程为子进程的提示、当前进程的PID 和父进程的PID、根据用户输入确定当前进程的返回值、退出提示等信息。② 在父进程中分别输出当前进程为父进程的提示、当前进程的PID 和子进程的PID、等待子进程退出后获得的返回值、退出提示等信息。（2）编写C程序，使用Linux中的IPC机制，完成 “石头、剪子、布”的游戏。
江西师范大学，操作系统，使用Linux中的IPC机制，完成 “石头、剪子、布”的游戏。
m0_63451467的博客
03-13 6834
由于学校实验任务，要用进程通信写一个多进程程序，本人用通信队列实现。
操作系统实验（七）：进程间通信
m0_62887657的博客
12-17 979
操作系统实验：进程间通信，包括writer和reader以及生产者的代码
(1)编写C程序，使用Linux中的IPC机制，完成“石头、剪子、布”的游戏修改上述程序，使之能够在网络上运行该游戏。
最新发布
12-16
要将经典的“石头、剪刀、布”游戏从本地Linux环境转换为网络运行，我们需要做以下几个步骤： 1. **选择通信机制**：由于需要网络支持，我们可以选择Socket编程作为基础的IPC（进程间通信）。Socket提供了一种标准的网络通信协议，使得应用程序能够相互通信。 2. **服务器端设计**：创建一个服务器端程序，它监听客户端的连接请求。当客户端连接后，服务器会发送游戏规则的信息，并接收客户端的选择。服务器负责管理游戏流程并判定胜负。 ```c #include <stdio.h> #include <stdlib.h> #include <sys/socket.h> #include <arpa/inet.h> // 简化的客户端-服务器通信结构 typedef struct { int server_sock; // 服务器套接字 char client_ip[INET_ADDRSTRLEN]; // 客户端IP地址 } ClientConnection; void* game_server(void* arg) { // ... 实现服务器端逻辑 ... } int main() { // 创建服务器套接字 ServerConnection server; if (socket(server.server_sock, SOCK_STREAM, 0) == -1) { perror("Error creating socket"); return 1; } // ... 绑定地址、监听等设置 ... // 启动服务器线程处理客户端连接 pthread_t server_thread; pthread_create(&server_thread, NULL, game_server, &server); // 等待客户端连接... } ``` 3. **客户端设计**：客户端也需要创建一个Socket连接到服务器，发送游戏选择，然后接收服务器的反馈。客户端可以是一个独立的应用程序，也可以是一个网页嵌入的游戏模块。 4. **数据序列化**：为了在网络上传输游戏状态和玩家选择，可能需要对数据进行序列化，如JSON或二进制格式。这一步骤用于编码游戏信息以便于跨平台传输。 5. **游戏逻辑**：在服务器和客户端上，都需要包含相同的“石头、剪刀、布”游戏逻辑，只是交互的方式不同。 6. **错误处理和安全性**：确保在整个过程中处理可能出现的连接断开、数据解析错误等问题，并考虑添加基本的安全措施，例如验证用户输入和保护敏感信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值