linux进程通信

e14: 进程间通信（进程之间发送/接收字符串/结构体）：

传统的通信方式：

管道（有名管道 fifo，无名管道 pipe）

信号 signal

System V(基于IPC的对象)：                             IPC对象：                                                    ipcrm [ -M key | -m id | -Q key | -q id | -S key | -s id ] ...

消息队列 message queue                              ipcs：                                                       ipcrm {shm|msg|sem} id...

共享内存 share memory                                    -m     shared memory segments

信号量集/信号灯集 semaphore                              -q     message queues

-s     semaphore arrays

-a     all (this is the default)

----------------------------------------------------------------------------

| System V的流程：                                                       |                                  system（） - execute a shell command

|   已经存在的路径名---->ftok()---->key---->IPC对象---->id---->使用      |                                    调用/bin/sh -c command,执行命令command

|                                                                          |

|    key-----shmget(),msgget(),semget()----->IPC对象（id号）             |

|        eg:key=ftok("/",'a');                                             |

|           id=msgget(key,IPC_CREAT|0666);                                 |

|           open(filename,O_CREAT,0666);                                   |

----------------------------------------------------------------------------

BSD：

套接字 socket

e14-1: 无名管道pipe（用于具有亲缘关系的进程,单向的数据传输通道）：

int pipe(int pipefd[2]);

pipefd[0]----读端，pipefd[1]----写端

----------------------------------------------------------------------

读端：

写端存在：

管道是有数据的，返回读取的字节数

管道是没有数据的，阻塞/等待直到管道中有数据

写端不存在：

管道是有数据的，返回读取的字节数

管道是没有数据的，返回0

写端：

读端存在：

管道有空间，返回写入的字节数

管道没有空间/空间不足，有多少写多少，直到写完返回

读端不存在：

进程被终止

e14-2: 有名管道fifo（first in first out）（用在独立的进程之间，双向的）：

有名管道是独立于进程存在的

有名管道可以看成由文件名标识的一根管道

创建：mkfifo

删除：unlink

监听：open（O_RDONLY）

开始会话：open(O_WRONLY)

两个进程通过FIFO进行通信：发送----write

接收----read

结束通信：close

----------------------------------------------------------------------

关于阻塞：

读端：open(O_RDONLY)；写端：open(O_WRONLY)

只有读端或者只有写端的时候，open调用会阻塞

验证方法：只运行read或者write程序

写端关闭：只剩下读端时，read立即返回0

读端关闭：只剩下写端时，写端会被终止

O_RDWR：两端都是O_RDWR方式打开时，两端都运行。如果一端退出，因为另一端以O_RDWR的方式打开，相当与自己也可以写，自己也可以读，在调用read，write时会阻塞

----------------------------------------------------------------------------------

多个进程读fifo：有名管道是一个队列，而不是常规文件。写端将字节写入队列，读端从队列的头部移出字节，每个读端都会将数据移出队列。所以如果想要保证读端都读到数据，写端必须要重写数据。

----------------------------------------------------------------------------------

竞态条件：FIFO不会出现竞态条件的问题。read和write系统调用是原子操作。读取操作将管道清空，而写入操作又将管道塞满。在读端和写端连通之前，系统内核会将进程挂起。

e14-3: 消息队列message queue：

key-----msgget()----->IPC对象（id号）

eg: 创建：key=ftok("/",'a');

id=msgget(key,IPC_CREAT|0666);

open(filename,O_CREAT,0666);

删除：msgctl：IPC_RMID

发送：msgsnd

接收：msgrcv

e14-4: 共享内存share memory：

最快速的进程间通信方式，适合大量数据的传输。他是一种高效率的进程间通信方式，进程可以直接读写内存空间，而不需要任何数据的copy

交互的时候不妨便，尤其是复杂的交互程序，需要同步/互斥

--------------------------------------------------------------------------------------------------------------------------------

共享内存的实现分为两个步骤：创建共享内存；映射共享内存,解除映射

创建/打开：shmget

删除：shmctl：IPC_RMID

内存映射：shmat:shmaddr--->内存映射指定的地址，若是NULL，表示由系统自动映射

shmflg---->默认是0，共享内存可读写，若是SHM_RDONLY，表示共享内存只读

内存解除映射：shmdt

e14-5: 信号量集/信号灯集semaphore：

信号量是一个内核变量，它可以被系统当中的任何进程所访问

进程之间可以使用这个变量来协调对于共享内存和其他资源的访问

信号量集是一个或多个信号量的一个集合，其中的每一个元素都是单独的信号量

信号量集机制------>解决进程间的同步与互斥

创建：semget

删除：semctl：IPC_RMID

初始化:semctl：SETVAL

修改：semop：sops---->结构体数组的首地址

nsops---->结构体数组的大小

结构体：struct sembuf{

unsigned short sem_num;  /* semaphore number */

short          sem_op;   /* semaphore operation */

short          sem_flg;  /* operation flags */

};

sem_op：

>0   对信号量的当前值进行增加

=0   等待直到信号量的值为0

<0   对信号量的当前值进行减少（如果不够减，就会等待）

sem_flag：SEM_UNDO，在进程终止前，对信号量进程恢复

e14-6: 信号signal：

信号来自内核

发送信号的方式：

1.键盘快捷键

2.内核在执行程序出错时。比如：非法段存取，浮点数溢出或除零运算

3.一个进程可以通过系统调用给另一个进程发送信号

特点：信号是一种异步通信方式，唯一的一种异步通信方式

信号可以直接进行用户空间过程和内核空间进程的交互

内核空间进程可以用信号来通知用户空间进程发生了哪些系统事件

------------------------------------------------------------------------------------------------------

用户空间进程对信号的响应方式：

1.忽略信号：对信号不做任何处理，其中，有两个信号不能忽略：SIGKILL（9） 和STGSTOP（10）

2.捕捉信号：定义信号处理函数，当信号发生时，执行相对应的信号处理函数

3.执行默认操作：linux对每种信号都规定了默认操作

--------------------------------------------------------------------------------------------------------

信号（kill -l）：

1.SIGHUP（终止进程）：

在用户终端连接结束的时候发出的，通常是终端的控制进程结束时，通知同一会话的各个进程组与控制终端不再连接

2.SIGINT（终止进程）：

用户输入“ctrl + c”时发出，前台进程中的每一个进程会接收到这个信号

3.SIGQUIT（终止进程）：

用户输入“ctrl + \”时发出

9.SIGKILL（终止进程）：

立即结束程序的运行，不能被忽略

14.SIGALRM（终止进程）：

当一个定时器到时的时候发送

===============================================================================================

| sleep：添加延时                                                                             |

| sleep(n)----将当前进程挂起n秒                                                               |

|    1.为SIGALRM设置处理函数                                                                  |

|    2.调用alarm（num_seconds）：设置一个定时器，在num_seconds秒之后发送SIGALRM信号           |

|       alarm也叫做闹钟函数，如果之前有设置定时器，前面设置的会失效                           |

|    3.pause（）：挂起进程直到信号到达，任何的信号都可以唤醒进程                              |

===============================================================================================

| usleep：实现精度更高的延时                                                                  |

|    int usleep(useconds_t usec);                                                             |

|                                                                                             |

|  获取或设置间隔计时器：                                                                     |

|   int getitimer(int which, struct itimerval *curr_value);                                   |

|   int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);  |

|                                                                                             |

|      which：获取或设置的计时器                                                              |

|           ITIMER_REAL：真实----------发送 SIGALRM                                           |

|           ITIMER_VIRTUAL：虚拟-------------发送 SIGVTALRM                                   |

|           ITIMER_PROF：实用----------发送 SIGPROF                                           |

|      struct itimerval 结构体                                                                |

|           struct itimerval {                                                                |

|   struct timeval it_interval; /* next value */                                  |

| struct timeval it_value;    /* current value */                               |

| };                                                                                |

|      struct timeval {                                                                       |

|           long tv_sec;                /* seconds */                                         |

|     long tv_usec;               /* microseconds */                                    |

|      };                                                                                     |

|                                                                                             |

|               tv_sec                  tv_usec                                               |

|       ----------------------------------------------                                        |

|    it_valuse    |                       |                （初始时间）                       |

|    it_interval  |                       |                （间隔时间）                       |

===============================================================================================

17.SIGCHLD（忽略）：

子进程改变状态的时候，父进程会收到这个信号

19.SIGSTOP（暂停进程，不消灭进程）：

用于暂停一个进程，且不能被忽略，不能定义处理函数

20.SIGTSTP（暂停进程，不消灭进程）：

用于暂停交互进程，用户输入“ctrl + z”发出信号

----------------------------------------------------------------------------------------------------------------

信号的处理函数的注册/关联/定义：

sighandler_t signal(int signum, sighandler_t handler);

signum：需要相应的信号

handler：如何相应/信号处理函数----SIG_DFL(将信号恢复为默认处理) or SIG_IGN（忽略信号）

-----------------------------------------------------------------------------------------------------------------

处理信号的流程：

一个正常的控制流/代码流，从main函数开始执行，然后从main函数返回另一个控制流/代码流，它是由信号引起的一个路径，进入信号处理函数，然后返回到调用它的代码中

-------------------------------------------------------------------------------------------------------------------

信号的发送：

kill（）：给进程或进程组发送一个信号  int kill(pid_t pid, int sig);   pid----正数，要接收信号的进程的pid                              sig：信号的编号

kill命令是kill函数的一个用户接口                                         ----0，信号被发送到所有和调用pid进程在统一个进程组的进程

raise（）：允许进程给自己发送信号                                        ---- -1，给所有的有权限的进程发送信号

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

signal 出现的问题：

信号排队：等待阻塞

信号处理函数被打断，信号嵌套，递归

不可靠的信号

对信号的操作/处理的3种方法：

1.递归

2.忽略

3.阻塞/等待

sigaction------指定什么信号将被如何处理/指定一个信号的处理函数

int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

signum----> 要处理的信号

act----> 指针，指向描述操作的结构 / 指向描述如何响应信号的结构

oldact----> 指针，指向描述被替换操作的结构 / 指向描述被替换的处理设置的结构

struct sigaction {

void     (*sa_handler)(int); --------->   跟signal类似，使用旧处理方式（SIG_DFL，SIG_IGN，处理函数）

void     (*sa_sigaction)(int, siginfo_t *, void *); ---------->  新的方式，不但可以得到信号编号，还可以获取被调用的原因以及产生问题的上下文

sigset_t   sa_mask; ---------------->  决定在处理一个信号的函数时，是否要阻塞其他信号。sa_mask 的值包括要被阻塞的信号的集合

int        sa_flags; ------->SA_RESETHAND：当处理函数被调用时会进行重置     SA_RESTART：当系统调用是针对一些慢速的设备或类似的系统调用，重新开始而不是返回

void     (*sa_restorer)(void);

};

一个 sigset_t 是一个抽象的信号量，可以通过一些函数来添加，删除信号的

int sigemptyset(sigset_t *set);   // 清除由set指向的集合中的所有信号

int sigfillset(sigset_t *set);    //添加所有的信号到set指向的集合

int sigaddset(sigset_t *set, int signum);    //添加signum到set指向的集合

int sigdelset(sigset_t *set, int signum);    //从set指向的集合中删除signum所标识的信号

======================================================================================================================================================================

临界区：

一段修改一个数据结构的代码，如果在运行时被打断将导致数据的不完整或损坏，那么称这段代码为临界区

阻塞信号：sigprocmask

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);   修改当前的信号掩码/屏蔽字

how------> 如何修改   SIG_BLOCK：添加    SIG_UNBLOCK：删除    SIG_SETMASK：替换/设置

set------> 指向使用的信号集

oldset---------> 指向之前的信号掩码/NULL

*******************************************************************************************************

eg：暂时的阻塞 SIGINT 和 SIGQUIT 信号

sigset_t sigs,prevsigs;

sigemptyset(&sigs);   //清空

sigaddset(&sigs,SIGINT);   //添加

sigaddset(&sigs,SIGQUIT);

sigprocmask(SIG_BLOCK,&sigs,&prevsigs);   //添加阻塞信号

//操作数据结构

sigprocmask(SIG_SETMASK,&prevsigs,NULL);   //恢复之前的prevsigs

e14-7: 套接字socket：

============================================================================================================================

|                                                                                                                          |

|  进程间通信方式总结：                                                                                                    |

|                                                                                                                          |

|     无名管道pipe：          具有亲缘关系的进程间进行使用，单向                                                           |

|                                                                                                                          |

|   有名管道fifo：          可以用在任意的进程之间，双向，有文件名                                                       |

|                                                                                                                          |

|   信号signal：            异步，不需要等待                                                                             |

|                                                                                                                          |

|   消息队列msgq：          消息是有类型的                                                                               |

|                                                                                                                          |

|   共享内存share memory：  效率最高，需要同步/互斥机制                                                                  |

|                                                                                                                          |

|   信号量集semaphore：     需要配合共享内存或者公共资源使用，可以实现同步/互斥机制，但是不能单独用于进程间信息的传递    |

|                                                                                                                          |

|   套接字socket：          可以跨主机进行进程间通信                                                                     |

|                                                                                                                          |

============================================================================================================================