系统编程（4）

哲学家就餐问题：

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

#define N 5

sem_t kuaizis[N];
sem_t room;

void *phi_thread_func(void *arg);

int main(int argc,char argv[])
{
    pthread_t thread_ids[N];
    int i = 0;
    sem_init(&room,0,4);
    
    for(i = 0;i < N;i++)
    {
        sem_init(&kuaizis[i], 0, 1);
    }
    for(i = 0;i < N;i++)
    {
        pthread_create(&thread_ids[i],NULL,phi_thread_func,(void *)i);
    }
    for(i = 0;i < N;i++)
    {
        pthread_join(thread_ids[i],NULL);
    }

    return 0;
}

void *phi_thread_func(void *arg)
{
    int thread_no = (int)arg;

    sem_wait(&room);    
    sem_wait(&kuaizis[thread_no]);
    sem_wait(&kuaizis[(thread_no+1)%N]);
    
    printf("pho NO.%d eating...\n",thread_no);
    
    sem_post(&kuaizis[(thread_no+1)%N]);
    sem_post(&kuaizis[thread_no]);
    sem_post(&room);
    
    pthread_exit(NULL);
}

进程间通信

无名管道,需要亲子进程来实现

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

#define BUFFER_SIZE 1024

// int pipe(int pipefds[2]);
// 参数：
//      pipefds 用于接收pipe函数创建的管道文件的读写文件描述符
//      pipefds[0]      指向管道文件的读端
//      pipefds[1]      指向管道文件的写端
// 返回值：成功返回0，失败，返回-1

int main(int argc, char *argv[])
{
    pid_t child_pid = 0;
    int pipe_fds[2] = {0};
    char buf[BUFFER_SIZE] = {'\0'};
    
    // 创建pipe
    if(pipe(pipe_fds) == -1)
    {
        perror("pipe failed");
        return 1;
    }
    
    // 数据从子进程传递给父进程
    if((child_pid = fork()) == 0)
    {
        int n = 0;
        // child process
        // 1.关闭子进程中管道的读文件描述符
        close(pipe_fds[0]);
        while(1)
        {
            // 2.从标准输入文件中读入数据
            n = read(STDIN_FILENO, buf, BUFFER_SIZE);   
            // 3.将读到的数据写入到管道中
            write(pipe_fds[1], buf, n);
        }
    }
    else if(child_pid > 0)
    {
        int n =0;
        // parent process
        // 1.在父进程中关闭管道的写文件描述符
        close(pipe_fds[1]);
        while(1)
        {
            // 2.从管道中读取数据
            n = read(pipe_fds[0], buf, BUFFER_SIZE);
            // 3.将从管道中读取的数据写入到标准输出文件
            write(STDOUT_FILENO, buf, n);
        }
    }
    else
    {
        // error
    }

    return 0;
}

利用有名管道产生不同窗口的本地聊天

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<string.h>

#define USER_NAME_MAX_LEN 100
#define MSG_MAX_LEN 500
#define FILE_NAME_MAX_LEN 100

struct msg_node
{
    char src_username[USER_NAME_MAX_LEN];
    char dst_username[USER_NAME_MAX_LEN];
    char text[MSG_MAX_LEN];
};

int main(int argc,char *argv[])
{
    if(argc != 2)
    {
        printf("usage:%s<username>\n",argv[0]);
        return -1;
    }
    
    char filename[FILE_NAME_MAX_LEN] = {'\0'};
    pid_t child_pid;

    
    sprintf(filename,"%s.fifo",argv[1]);
    if(access(filename,F_OK) != 0)
    {
        mkfifo(filename,S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    }
    
    if((child_pid = fork()) == 0)
    {
        int n = 0;
        struct msg_node msg;
        int fd = 0;
        while(1)
        {
            if((fd = open(filename,O_RDONLY)) == -1)
            {
                perror("open failed");
                return -1;
            }   
            while((n = read(fd,&msg,sizeof(msg))) > 0)
            {
                printf("%s ----> %s : %s\n",msg.src_username,msg.dst_username,msg.text);
            }
        
            close(fd);
        }
    }
    
    else if(child_pid > 0)
    {
        //char buf[MSG_MAX_LEN] = {'\0'};
        struct msg_node msg;
        int fd = 0;
        char dst_filename[FILE_NAME_MAX_LEN] = {'\0'};
        
        strcpy(msg.src_username,argv[1]);
        
        while(1)
        {
            printf("to>");
            fgets(&msg.dst_username,USER_NAME_MAX_LEN,stdin);
            msg.dst_username[strlen(msg.dst_username)-1] = '\0';
            
            printf("text>");
            fgets(&msg.text,MSG_MAX_LEN,stdin);
            msg.text[strlen(msg.text)-1] = '\0';
            
            sprintf(dst_filename,"%s.fifo",msg.dst_username);
            
            //printf("%s\n",dst_filename);
            
            if((fd = open(dst_filename,O_WRONLY)) == -1)
            {
                perror("open failed");
                continue;
            }
            //printf("*****\n");
            write(fd,&msg,sizeof(msg));
            
            close(fd);
        }
    }
    else
    {
    
    }
    
    remove(filename);
    return 0;
}

共享内存间通信，使用信号量，效率最高
两个进程实现教师信息的传递

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
#include <stdlib.h>

#define ARR_MAX_LEN 100

int main(int argc, char *argv[])
{
    int shmid = 0;
    struct teacher_node
    {
        int tea_id;
        char tea_name[ARR_MAX_LEN];
        int tea_age;
        char tea_favite[ARR_MAX_LEN];
    };
    key_t key;
    struct teacher_node teacher;
    memset(&teacher, 0, sizeof(teacher));
    
    key = ftok("/", 'j');
    if((shmid = shmget(key, sizeof(teacher), IPC_CREAT | S_IRUSR | S_IWUSR)) == -1)
    {
        perror("shmget failed");
        return -1;
    }
   // printf("shmid = %d\n",shmid);
    
    teacher.tea_id = 123;
    strcpy(teacher.tea_name,"xiaowang");
    teacher.tea_age = 23;
    strcpy(teacher.tea_favite,"basketball");
    
    struct teacher *p = shmat(shmid, NULL, 0);
    //getchar();
   // printf("input teacher msg:id,name,age,favite\n");

        // 2.3将输入的教师信息拷贝
    memcpy(p, &teacher, sizeof(teacher));

    shmdt(&teacher);

    return 0;
}

进程间同步同步共享资源

// 本文件是对信号量集中只有一个信号量的操作的封装

#ifndef __SQ_SEM_H__
#define __SQ_SEM_H__

#include <sys/types.h>

// semctl函数的第四个参数类型
union semun {
    int val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short *array;  /* Array for GETALL, SETALL */
    struct seminfo *__buf;  /* Buffer for IPC_INFO
                                           (Linux-specific) */
};

// 创建/获取信号量集
int sq_sem_get(key_t key, int semflg);

// 初始化信号量集
int sq_sem_init(int semid, int value);

// 对信号量集进行wait操作（-1）
int sq_sem_wait(int semid);

// 对信号量集进行post操作（+1）
int sq_sem_post(int semid);

// 销毁信号量集
int sq_sem_destroy(int semid);
#endif
_____

#include "sq_sem.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

// 创建/获取信号量集
int sq_sem_get(key_t key, int semflg)
{
    return semget(key, 1, semflg);
}

// 初始化信号量集
int sq_sem_init(int semid, int value)
{
    union semun arg;
    arg.val = value;
    
    return semctl(semid, 0, SETVAL, arg);
}

// 对信号量集进行wait操作（-1）
int sq_sem_wait(int semid)
{
    struct sembuf s_op;
    s_op.sem_num = 0;
    s_op.sem_op = -1;
    s_op.sem_flg = SEM_UNDO;
    
    return semop(semid, &s_op, 1);
}

// 对信号量集进行post操作（+1）
int sq_sem_post(int semid)
{
    struct sembuf s_op;
    s_op.sem_num = 0;
    s_op.sem_op = 1;
    s_op.sem_flg = SEM_UNDO;
    
    return semop(semid, &s_op, 1);
}


// 销毁信号量集
int sq_sem_destroy(int semid)
{
    return semctl(semid, 0, IPC_RMID);
}

_____

// 模拟在父进程和子进程之前以共享内存的方式交换数据
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include "sq_sem.h"

struct teacher
{
    int no;
    char name[50];
};

int main(int argc, char *argv[])
{
    pid_t child_pid = 0;
    int sem_id = 0;
    int shm_id = 0;
    key_t key;
    
    // 生成唯一key值用于获取信号量集和共享内存
    key = ftok("/", 'a');
    // 1.1获取共享内存
    if((shm_id = shmget(key, sizeof(struct teacher), IPC_CREAT | 0600)) == -1)
    {
        perror("shmget failed");
        return 1;
    }
    // 1.2获取信号量集用于同步使用共享内存
    if((sem_id = sq_sem_get(key, IPC_CREAT | 0666)) == -1)
    {
        perror("sq_sem_get failed");
        return 2;
    }
    // 1.3初始化信号量集
    sq_sem_init(sem_id, 0);
    
    if((child_pid = fork()) == 0)   // 子进程
    {
        // 用于存储从共享内存中获取的数据
        struct teacher teach;
        memset(&teach, 0, sizeof(teach));
        
        // 子进程负责从共享内存中读入数据
        // 2.1绑定共享内存
        struct teacher *p = (struct teacher *)shmat(shm_id, NULL, 0);
        
        // 2.2先wait信号量，确保共享内存中有数据可读
        sq_sem_wait(sem_id);
        
        // 2.3从共享内存中读出数据
        memcpy(&teach, p, sizeof(teach));
        
        // 2.4打印读出的数据
        printf("techer : no = %d, name = %s\n",
            teach.no, teach.name);
            
        // 3.解除共享内存的绑定
        shmdt(p);
              
        // 子进程退出    
        exit(0);
    }
    else if(child_pid > 0)          // 父进程
    {
        // 用于存储从键盘读入的教师信息
        struct teacher teach;
        memset(&teach, 0, sizeof(teach));
        
        // 父进程负责从键盘读入教师信息，写入共享内存
        // 2.1从键盘读入教师信息
        printf("input no>");
        scanf("%d", &teach.no);
        printf("input name>");
        scanf("%s", teach.name);
        
        // 2.2绑定共享内存
        struct teacher *p = (struct teacher *)shmat(shm_id, NULL, 0);
        
        // 2.3将输入的教师信息拷贝
        memcpy(p, &teach, sizeof(teach));
        
        // 2.4对信号量集进行post操作
        sq_sem_post(sem_id);
        
        // 3.解除共享内存的绑定
        shmdt(p);
        
        // 防止僵尸进程    
        wait(NULL);  
        
        // 父进程退出
        exit(0);
    }
    else
    {
    }

    return 0;
}