2023/8/22 -- 进程线程

作业：

        两个非亲缘进程间的通信

#include <myhead.h>

int main(int argc, const char *argv[])
{
	pid_t pid1;
	pid1 = fork();
	if(pid1 < 0){
		perror("pid1 fork error");
		return -1;
	}else if(pid1 == 0){
		printf("子进程1创建成功\n");

		mkfifo("./myfifo1",0664);

		int fd1_write = open("./myfifo1",O_WRONLY);
		if(fd1_write == -1){
			perror("fd1_write open error");
			return -1;
		}

		while(1){
			char buf[32] = {};
			fgets(buf,sizeof(buf),stdin);
			buf[strlen(buf)-1] = '\0';
			write(fd1_write,buf,strlen(buf));
			if(strcmp(buf,"exit") == 0){
				break;
			}
		}
		close(fd1_write);

		sleep(1);

		int fd2_read = open("./myfifo2",O_RDONLY);
		if(fd2_read == -1){
			perror("fd2_read open error");
			return -1;
		}

		while(1){
			char buf[32] = {};
			read(fd2_read,buf,sizeof(buf));
			if(strcmp(buf,"exit") == 0){
				break;
			}
			printf("进程2已写：%s\n",buf);
		}
		close(fd2_read);

		exit(EXIT_SUCCESS);
	}else{
		pid_t pid2;
		pid2 = fork();
		if(pid2 < 0){
			perror("pid2 fork error");
			return -1;
		}else if(pid2 == 0){
			sleep(1);
			printf("子进程2创建成功\n");

			int fd1_read = open("./myfifo1",O_RDONLY);
			if(fd1_read == -1){
				perror("fd1_read open error");
				return -1;
			}

			while(1){
				char buf[32] = {};
				read(fd1_read,buf,sizeof(buf));
				if(strcmp(buf,"exit") == 0){
					break;
				}
				printf("进程1已写：%s\n",buf);
			}
			close(fd1_read);

			mkfifo("./myfifo2",0664);

			int fd2_write = open("./myfifo2",O_WRONLY);
			if(fd2_write == -1){
				perror("fd2_write open error");
				return -1;
			}

			while(1){
				char buf[32] = {};
				fgets(buf,sizeof(buf),stdin);
				buf[strlen(buf)-1] = '\0';
				write(fd2_write,buf,strlen(buf));
				if(strcmp(buf,"exit") == 0){
					break;
				}
			}
			close(fd2_write);

			exit(EXIT_SUCCESS);

		}else{
			printf("父进程创建成功\n");
			wait(NULL);
			wait(NULL);
		}
	}

	return 0;
}

效果图：

一、线程的同步互斥机制

1.1 同步互斥相关基本概念

• 临界资源（共享资源）：在多任务并发执行时，访问的同一个资源
• 临界区：访问临界资源的代码
• 竞态：多个任务共同抢占临界资源的现象叫做竞态
• 互斥：指某一个临界资源同一时刻只允许一个访问者，具有唯一性和排他性
• 同步：使用相关手段，将任务有先后顺序的执行
• 解决竞态的方法：互斥锁、无名信号量、条件变量

1.2 互斥锁

1> 互斥锁的使用逻辑：

1. 给临界区上锁，获取到锁的线程可以使用临界资源
2. 释放锁，当一个线程释放锁资源后，其他线程对该锁可以继续抢占
3. 互斥锁被一个任务抢占后，其他任务就不能获取到该锁资源了
4. 互斥锁的本质是一个全局变量

2> 互斥锁的API

       #include <pthread.h>
       1、初始化一个互斥锁

       pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;            //静态初始化

       pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;

       pthread_mutex_t errchkmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
       
       2、初始化一个互斥锁                                                 

       int pthread_mutex_init(pthread_mutex_t *mutex,  const  pthread_mutexattr_t
 *mutexattr);
       功能：初始化一个互斥锁
       参数1：互斥锁变量的地址，是一个指针
       参数2：互斥锁的状态，默认为NULL
       返回值：永远返回0
        
       3、上锁                    

       int pthread_mutex_lock(pthread_mutex_t *mutex);
       功能：给临界区上锁，获取锁资源
       参数：互斥锁地址
       返回值：成功返回0，失败返回非0错误码               

       int pthread_mutex_trylock(pthread_mutex_t *mutex);
       
       4、解锁 

       int pthread_mutex_unlock(pthread_mutex_t *mutex);
       功能：释放锁资源
       参数：互斥锁
       返回值：成功返回0，失败返回非0错误码 
       
        5、销毁锁

       int pthread_mutex_destroy(pthread_mutex_t *mutex);
       功能;销毁互斥锁
       参数：互斥锁地址
       返回值：成功返回0，失败返回非0错误码 

1.3 线程同步之无名信号量

1> 线程同步：在已经知道线程的执行顺序，并且线程是按顺序进行执行，这种操作称为线程同步

2> 线程同步适用的模型：生产者消费者模型。即生产者先生成商品，然后，消费者在对商品进行消费

3> 无名信号量的api

1、要定义一个无名信号量
    sem_t sem;                //定义一个信号量
2、初始化信号量
           #include <semaphore.h>

       int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：初始化一个无名信号量
参数1：无名信号量地址
参数2：进程或线程同步的标识
            0:表示多线程之间的同步
            1:表示多个进程之间的同步（亲缘间）
参数3：无名信号量维护的value值，每进行一次wait，那么该值就会减1，每进行一次post，该值就会加1，当该值为0时，wait会阻塞
返回值：成功返回0，失败返回-1并置位错误码

3、申请资源
           #include <semaphore.h>

       int sem_wait(sem_t *sem);
功能：申请当前无名信号量的资源，使得value值减1，当资源为0时，该函数会被阻塞，直到alue值大于0
参数：无名信号量地址
返回值：成功返回0，失败返回-1并置位错误码，而且value值不变

4、释放资源
           #include <semaphore.h>

       int sem_post(sem_t *sem);
功能：释放资源（V操作，使得value值加1）
参数：无名信号量地址
返回值：成功返回0，失败返回-1并置位错误码，并且value的值不会改变

5、销毁无名信号量
           #include <semaphore.h>

       int sem_destroy(sem_t *sem);
功能：销毁无名信号量
参数：无名信号量地址
返回值：成功返回0，失败返回-1并置位错误码

1.4 线程同步之条件变量

1> 无名信号量维护了一个value值，而条件变量维护了一个队列

2> 条件变量对应的模型：生产者消费者模型（一个生产者对应多个消费者）

3> 条件变量的API

       #include <pthread.h>
       1、定义一个条件变量

       pthread_cond_t cond = PTHREAD_COND_INITIALIZER;           //静态初始化
       2、初始化条件变量

       int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
       功能：动态初始化一个条件变量
       参数1：条件变量的地址
       参数2：条件变量的属性，默认为NULL
       返回值：成功返回0，失败返回非0的错误码
       
        3、给休眠的线程发送唤醒信号

       int pthread_cond_signal(pthread_cond_t *cond);
       功能：唤醒休眠队列中的对头线程
       参数：条件变量的地址
       返回值：成功返回0，失败返回非0的错误码

       int pthread_cond_broadcast(pthread_cond_t *cond);
       功能：唤醒休眠队列中的所有线程
       参数：条件变量的地址
       返回值：成功返回0，失败返回非0的错误码
       
        4、阻塞等待条件变量

       int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
       功能：等待条件变量，并让该线程进入休眠队列
       参数1：条件变量
       参数2：互斥锁，由于进入休眠队列时可能会产生竞态，所以需要一把互斥锁
       返回值：成功返回0，失败返回非0的错误码
       
        5、销毁条件变量        



       int pthread_cond_destroy(pthread_cond_t *cond);
       功能：销毁条件变量
       参数：条件变量地址
       返回值：成功返回0，失败返回非0的错误码

二、进程间通信（IPC）

2.1 相关概念

1> IPC: inter process communication

2> 线程间通信，可以使用全局变量来完成，原因是多个线程共享进程的资源

3> 由于进程间通信时，每个进程的用户空间是独立的，所以不能使用全局变量来完成进程间的通信

4> 可以使用文件来完成两个进程间通信，一个进程向文件中写数据，另一个进程从文件中读数据，但是，又因为进程的调度是时间片轮询，上下文切换，所以，不确定先执行哪一个进程，文件操作有些行不通，但是不完全行不通

5> 由于多个进程用户空间是独立的，但是共享内核空间

6> 进程间通信的种类

        内核提供的传统通信方式：

                1、无名管道

                2、有名管道

                3、信号

        system V提供了三种：

                4、消息队列

                5、共享内存

                6、有名信号量（信号灯集）

        用于跨主机传输的通信

                7、socket 套接字通信（网络编程重点说明）

2.2 管道

1> 管道的原理

在3--4G内核空间中，创建一个特殊的文件（管道文件），管道文件直接保存在内存中

2> 管道的特性

1、管道可以看成特殊的文件，一般文件存储在磁盘文件中，而管道文件可以存在内存中

2、管道文件遵循的规则是先进先出，被读取的文件不会再管道文件中存留

3、对管道的操作是一次性的

4、管道通信的方式是一种半双工的通信方式

                单工：只能A向B发送数据，B不能向A发送数据

                半双工：在同一时间只能是A发个B数据，或B发给A数据

                全双工：同一时间内，A可以向B发数据，B也可向A发数据

5、在对管道操作时，只能使用文件IO进行操作，因为打开管道时，会提供读端和写端的两个文件描述符

6、当管道文件所有的读端和写端都被关闭后，管道文件会自动关闭

7、管道文件的大小：64K = 65536Byte

2.3 无名管道

1> 无名管道顾名思义就是没有名字的管道文件，由于该文件没有名字，导致其他进程不能打开该文件，所以就不能完成非亲缘间的进程的通信

2> 无名管道适用于亲缘进程间的通信

3> 无名管道的API

       #include <unistd.h>

       int pipe(int pipefd[2]);
功能：创建一个管道，用于进程间通信，并通过参数返回该管道的两端，pipefd[0]是管道文件的读端，pipefd[1]是管道文件的写端
参数：整形数组，存放管道文件的文件描述符
返回值：成功返回0，失败返回-1并置位错误码

4> 无名管道的特点

1、无名管道适用于亲缘进程间通信，也可以适用于自己跟自己通信

2、管道文件的大小为64K

3、在读写管道文件时，不能使用lseek移动光标

4、读写的特点

如果读端存在，写管道，有多少写多少，直到写满64K，就进入阻塞

如果读端不存在，写管道破裂，并且会发射一个SIGPIPE信号

如果写端存在，读管道有多少读多少，管道中没有数据，会在read处阻塞

如果写端不存在，读管道有多少读多少，如果管道中没有数据，也不会阻塞

2.4 有名管道

1> 有名管道顾名思义就是有名字的管道，在创建管道文件时，会给出管道文件的名称

2> 有名管道适用于亲缘或非亲缘进程间的通信

3> 有名管道的api

       #include <sys/types.h>
       #include <sys/stat.h>

       int mkfifo(const char *pathname, mode_t mode);
       功能：创建一个有名管道文件
       参数1：有名管道文件的名字
       参数2：文件权限，需要&上~umask
       返回值：成功返回0，失败返回-1并置位错误码

2.5 信号实现进程间通信

1> 信号的使用机制

在linux应用层的信号，其实是模拟底层的中断，当一个进程正在运行时，如果有信号产生，则会执行该信号对应的操作

2> 信号的处理方式

1. 捕获：当捕获一个信号后，可以进行处理信号处理函数
2. 忽略：当信号发射后，不做任何处理
3. 默认：一般都是杀死进程

3> 信号的种类及功能：可以通过 kill -l查看所有信号

4> 常用的信号及处理方式

注意：

• SIGKILL和SIGSTOP信号既不能被捕获，也不能被忽略，只能默认处理
• SIGUSR1和SIGUSR2这两个信号，没有具体的使用场景，是内核提供给用户自己使用的
• 还有SIGCHLD信号很重要，当子进程死后，会向父进程发射该信号

5> 绑定信号函数（signal）

       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);
功能：将指定的信号与信号处理函数进行绑定，当信号发射时，信号处理函数就会被执行
参数1：要绑定的信号
参数2：信号处理函数
        SIG_IGN:表示忽略该信号
        SIG_DFL:表示默认处理该信号
        传递一个参数为int类型返回值为void类型的函数名，该函数就是信号处理函数，当信号被发射后，该函数就会自动被执行
返回值：成功返回信号处理函数的地址，失败返回SIG_ERR并置位错误码

6> 使用信号的方式回收僵尸进程

1、当子进程生命周期结束后，会向父进程发射一个SIGCHLD信号，告诉父进程，我死了

2、父进程接收到该信号后，可以将该信号捕获，并在信号处理函数中，以非阻塞的形式为子进程收尸（waitpid）

3、如果有多个子进程死了，父进程会接受多个SIGCHLD信号，但是，最终只会处理最后一个，导致其他进程还是僵尸进程

4、如果成功回收子进程，并以非阻塞形式回收

        =0：表示回收内存成功，并且有活着的子进程，该函数再次运行还会成功

        =-1；表示回收成功，并且没有活着的子进程了，该函数再次运行会失败

#include<myhead.h>

//定义信号处理函数
void handler(int signum)
{
    if(signum == SIGCHLD)
    {
        //回收子进程的资源
        //waitpid(-1, NULL, WNOHANG);    //此时只回收一个子进程
    /*
        //循环回收子进程资源
        while(1)
        {
            pid_t w = waitpid(-1, NULL, WNOHANG);

            if(w <= 0)
            {
                break;
            }
        }
        */
    
        while(waitpid(-1, NULL, WNOHANG) > 0);

    }
}

int main(int argc, const char *argv[])
{
    //先绑定SIGCHLD信号到自定义处理函数中
    if(signal(SIGCHLD, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }

    //循环创建子进程，并且杀死子进程
    for(int i=0; i<100; i++)
    {
        if(fork() == 0)        //创建的子进程直接杀死变成僵尸进程
        {
            exit(EXIT_SUCCESS);
        }
    }

    while(1);

    return 0;
}

7> 发射信号函数（kill / raise）

       #include <signal.h>

       int kill(pid_t pid, int sig);
公共：向指定的进程或进程组发射信号
参数1：进程号
    >0 :表示向指定的进程发送信号
    =0: 表示向当前进程所在的进程组的每个进程发送该信号
    =-1：表示向所有有收发信号权限的进程发送该信号
    <-1: 表示向绝对值为pid的进程组中的所有进程发送该信号
参数2：要发送的信号号
返回值：成功返回0，失败返回-1并置位错误码

       #include <signal.h>

       int raise(int sig);
功能：给自己发送一个信号
参数：信号号
返回值：成功返回0，失败返回非0

8> SIGALRM信号的使用

1、当调用alrm函数时，定时器时间到位后，回向该进程发射一个SIGALRM信号

2、alarm函数

       #include <unistd.h>

       unsigned int alarm(unsigned int seconds);
功能：创建一个定时器
参数：时长，以秒为单位
返回值：如果之前没有定时器，则返回0，如果之前已经启动定时器了，则返回上一个定时器锁剩余的秒数

2.6 系统V提供的进程间通信

1> 种类  ：消息队列、共享内存、信号灯集

2> 查看相关的指令

• ipcs :可以查看所有的进程间通信的信息（包括消息队列、共享内存、信号灯）
• ipcs -q :单独查看消息队列的信息
• ipcs -m :单独查看共享内存的信息
• ipcs -s :单独查看信号量的信息
• ipcrm -q\-m\-s ID ：删除为ID的进程间通信对象

2.7 消息队列

1> 消息队列原理图

2> 有关消息队列的API

1、获取key值函数
      #include <sys/types.h>
       #include <sys/ipc.h>

       key_t ftok(const char *pathname, int proj_id);
功能：创建一个key值
参数1：需要一个已存在的路径
参数2：一个项目id，就是任意一个数
注：（key值的组成：proj_id(高8位) + st_dev(8位) + inode（剩余16位））
返回值：成功返回创建的key值，失败返回-1并置位错误码

2、创建消息队列对象

       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/msg.h>

       int msgget(key_t key, int msgflg);
功能：通过给定的key值，创建一个消息队列
参数1：key值，可以是IPC_PRIVATE，如果是IPC_PRIVATE，则该消息队列适用于亲缘进程间通信
参数2：消息队列的标志位
        IPC_CREAT|0666     //如果消息队列不存在，则创建一个消息队列，如果消息队列存在，则打开消息队列
        IPC_CREAT|IPC_EXCL|0666      //如果消息队列不存在，则创建，如果消息队列存在，则报错EEXIST错误
返回值：成功返回创建的消息队列的id，失败返回-1并置位错误码

3、向消息队列中发送数据
       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/msg.h>

       int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
功能：向给定的消息队列中发送数据
参数1：消息队列的id号
参数2：要发送消息的地址
参数3：消息正文的大小
参数4：发送消息的标志位
        0：阻塞方式进行发射消息
        IPC_NOWAIT:非阻塞方式调用
返回值:    成功返回0，失败返回-1并置位错误码，消息队列的大小为16K（16384字节）
消息结构体定义格式
 struct msgbuf {
               long mtype;       /* message type, must be > 0 */    //消息类型放在第一位，占8字节
               char mtext[1];    /* message data */           //正文部分
           };
 正文大小：sizeof(struct msgbuf) - sizeof(long)                    
 
4、从消息队列中取数据                                              

       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
 int msgflg);
功能：从给定的消息队列中取出消息内容
参数1：消息队列
参数2：消息容器指针
参数3：正文大小
参数4：消息类型
        = 0：每次从消息队列中读取第一个
        >0:读取队列中的第一个为该类型的消息
        <0:读取队列中第一个类型小于等于该值的绝对值的消息
参数5：接受消息的标志位
        0：阻塞方式进行接收消息
        IPC_NOWAIT:非阻塞方式调用

5、消息队列控制
       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/msg.h>

       int msgctl(int msqid, int cmd, struct msqid_ds *buf);
功能：消息队列的控制
参数1：消息队列id
参数2：控制方式：
    IPC_STAT:获取消息队列的状态
    IPC_SET：设置消息队列的状态
    IPC_RMID:删除当前的消息队列，如果第二个参数为IPC_RMID，则第三个参数填NULL即可
    IPC_INFO：获取消息队列的信息
参数3：消息队列信息结构体      
struct msqid_ds {
               struct ipc_perm msg_perm;     /* Ownership and permissions */    权限
               time_t          msg_stime;    /* Time of last msgsnd(2) */   最后一次向队列发送消息的时间
               time_t          msg_rtime;    /* Time of last msgrcv(2) */最后一次从队列读消息的时间
               time_t          msg_ctime;    /* Time of last change */   最后一次更改消息队列的时间
               unsigned long   __msg_cbytes; /* Current number of bytes in    当前队列中的数据大小
                                                queue (nonstandard) */
               msgqnum_t       msg_qnum;     /* Current number of messages     当前队列中消息个数
                                                in queue */
               msglen_t        msg_qbytes;   /* Maximum number of bytes     最大的字节数：16K
                                                allowed in queue */
               pid_t           msg_lspid;    /* PID of last msgsnd(2) */   最后一次向队列发消息的进程的pid
               pid_t           msg_lrpid;    /* PID of last msgrcv(2) */  最后一次从消息队列中读数据的进程pid
           };
      第一个成员的结构体
  struct ipc_perm {
               key_t          __key;       /* Key supplied to msgget(2) */    创建消息队列的key值
               uid_t          uid;         /* Effective UID of owner */     用户id
               gid_t          gid;         /* Effective GID of owner */    组id
               uid_t          cuid;        /* Effective UID of creator */   创建者的uid
               gid_t          cgid;        /* Effective GID of creator */   创建者的组id
               unsigned short mode;        /* Permissions */        权限
               unsigned short __seq;       /* Sequence number */    队列号
           };
                                      
  

2.8 共享内存

1> 共享内存原理

2> 共享内存的API

(1)创建共享内存
int shmget(key_t key, size_t size, int shmflg);
功能:获取共享内存段的ID 
参数:
    @key :IPC_PRIVATE  或 ftok() 
    @size:申请的共享内存段大小 [4k的倍数]
    @shmflg:创建消息队列的标志位
        IPC_CREAT | 0666      //如果共享内存不存在就创建，如果存在就返回共享内存的ID
        或 
        IPC_CREAT | IPC_EXCL | 0666 //如果共享内存不存在就创建，如果存在就报已存在错误
返回值:成功返回ID,失败返回-1 

(2)映射内存
void *shmat(int shmid, const void *shmaddr, int shmflg);
功能:映射共享内存到用户空间 
参数:
    @shmid  :共享内存段ID 
    @shmaddr:映射到的地址
            NULL:系统自动完成映射 
    @shmflg :共享内存操作的标志位
            SHM_RDONLY:只读   
            0:读写
返回值:成功返回映射后的地址，失败返回(void *)-1 
  
(3)撤销映射
int shmdt(const void *shmaddr);
功能:撤销映射
参数:
    @shmaddr  共享内存映射的地址 
返回值：成功返回0，失败返回-1置位错误码
注意:当一个进程结束的时候，它映射共享内存，会自动撤销映射
           
（4）共享内存控制
       #include <sys/ipc.h>
       #include <sys/shm.h>

       int shmctl(int shmid, int cmd, struct shmid_ds *buf);
功能：操作共享内存
参数1：共享内存id
参数2：控制方式
        IPC_STAT：队列的状态
            如果参数2位该值，则参数三就是当前队列的状态，使用一个结构体进行接收，结构体类型：
            struct msqid_ds {
               struct ipc_perm msg_perm;     /* Ownership and permissions */
               time_t          msg_stime;    /* Time of last msgsnd(2) */
               time_t          msg_rtime;    /* Time of last msgrcv(2) */
               time_t          msg_ctime;    /* Time of last change */
               unsigned long   __msg_cbytes; /* Current number of bytes in
                                                queue (nonstandard) */
               msgqnum_t       msg_qnum;     /* Current number of messages
                                                in queue */
               msglen_t        msg_qbytes;   /* Maximum number of bytes
                                                allowed in queue */
               pid_t           msg_lspid;    /* PID of last msgsnd(2) */
               pid_t           msg_lrpid;    /* PID of last msgrcv(2) */
           };
           
            该结构体的第一个成员：
             struct ipc_perm {
               key_t          __key;       /* Key supplied to msgget(2) */
               uid_t          uid;         /* Effective UID of owner */
               gid_t          gid;         /* Effective GID of owner */
               uid_t          cuid;        /* Effective UID of creator */
               gid_t          cgid;        /* Effective GID of creator */
               unsigned short mode;        /* Permissions */
               unsigned short __seq;       /* Sequence number */
           };


            IPC_SET：设置消息队列的属性
            如果参数2位该值，更改当前消息队列的信息，需要传入一个结构体变量，在主调函数中初始化后，进行传递，结构体类型如上：
            
            IPC_RMID：删除某个队列，如果第二个参数为IPC_RMID，那么第三个参数可以填NULL（常用）
             IPC_INFO：如果参数是这个，则会在第三个参数中返回消息队列的信息
参数3：状态的指针
返回值：成功返回0，失败返回-1并置位错误码