目录
练习:父子进程实现通信,父进程循环从终端输入数据,子进程循环打印数据,当输入quit结束。
【1】进程间通信 IPC
1》 进程间通信方式
(1)早期的进程间通信:
无名管道(pipe)、有名管道(fifo)、信号(signal)
(2)system V PIC:
共享内存(share memory)、信号灯集(semaphore)、消息队列(message queue)
(3)BSD:
套接字(socket)
2》 无名管道
1> 特点
(1)只能用于具有亲缘关系的进程之间的通信
(2)半双工的通信模式,具有固定的读端fd[0]和写端fd[1]。
(3)管道可以看成是一种特殊的文件,对于它的读写可以使用文件IO如read、write函数。
(4)管道是基于文件描述符的通信方式。当一个管道建立时,它会创建两个文件描述符 fd[0]和fd[1]。其中fd[0]固定用于读管道,而fd[1]固定用于写管道。
2> 函数接口
int pipe(int fd[2])
功能:创建无名管道
参数:文件描述符 fd[0]:读端 fd[1]:写端
返回值:成功 0
失败 -1
#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
char buf[65536] = "";
int fd[2] = {0}; //fd[0]代表读端,fd[1]代表写端
if (pipe(fd) < 0)
{
perror("pipe err");
return -1;
}
printf("%d %d\n", fd[0], fd[1]);
//结构类似队列,先进先出
//1. 当管道中无数据时,读阻塞。
// read(fd[0], buf, 32);
// printf("%s\n", buf);
//但是关闭写端就不一样了
//当管道中有数据关闭写端可以读出数据,无数据时关闭写端读操作会立即返回。
// write(fd[1], "hello", 5);
// close(fd[1]);
// read(fd[0], buf, 32);
// printf("%s\n", buf);
//2. 当管道中写满数据时,写阻塞,管道空间大小为64K
// write(fd[1], buf, 65536);
// printf("full!\n");
//write(fd[1], "a", 1); //当管道写满时不能再继续写了会阻塞
//写满一次之后,当管道中至少有4K空间时(也就是读出4K),才可以继续写,否则阻塞。
// read(fd[0], buf, 4096); //换成4095后面再写就阻塞了,因为不到4K空间
// write(fd[1], "a", 1);
//3. 当读端关闭,往管道中写入数据无意义,会造成管道破裂,进程收到内核发送的SIGPIPE信号。
close(fd[0]);
write(fd[1], "a", 1);
printf("read close\n");
return 0;
}
用gdb调试可以看见管道破裂信号:
gcc -g xx.c
gdb a.out
r
3> 注意事项
(1)当管道中无数据时,读操作会阻塞
管道中有数据,将写端关闭,可以将数据读出
管道中无数据,将写端关闭,读操作会立即返回
(2)管道中装满(管道大小64K)数据写阻塞,一旦由 4k 空间,写继续
(3)只有在管道的读端存在时,向管道中写入数据才有意义,否则,会导致管道破裂,向管道中写入数据的进程将收到内核传来的SIGPIPE信号(通常Broken pipe错误)
练习:父子进程实现通信,父进程循环从终端输入数据,子进程循环打印数据,当输入quit结束。
提示:不需要加同步机制, 因为pipe无数据时读会阻塞。
先创建管道再fork,这样父子进程可以使用同一个无名管道。
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char const *argv[])
{
char buf[32];//定义一个数组
int fd[2];//定义两个文件描述符
if (pipe(fd) < 0)//创建管道并判断
{
perror("pipe err\n");
return -1;
}
printf("%d %d\n", fd[0], fd[1]);//打印一下文件描述符
int pid;
pid = fork();//创建父子进程
if (pid < 0)//创建失败
{
perror("fork err\n");
return -1;
}
else if (pid == 0)//子进程
{
while (1)
{
read(fd[0], buf, 32);//从读端读取管道中的数据到buf中
printf("%s\n", buf);//打印buf中的数据
}
}
else//父进程
{
while (1)
{
scanf("%s", buf);//从终端输入数据到buf中
if (strcmp(buf, "quit") == 0)//判断输入的是否为 quit,若是,则退出循环
{
break;
}
write(fd[1], buf, 32);//将 buf 中的数据从写端写到管道中
}
}
return 0;
}
3》有名管道
1> 特点
(1)有名管道可以使互不相关的两个进程互相通信。
(2)有名管道可以通过路径名来指出,并且在文件系统中可见,但内容存放在内存中。但是读写数据不会存在文件中,而是在管道中。
(3)进程通过文件IO来操作有名管道。
(4)有名管道遵循先进先出规则
(5)不支持如lseek()操作
2> 函数接口
int mkfifo(const char *filename,mode_t mode);
功能:创健有名管道
参数:filename:有名管道文件名
mode:权限
返回值:成功:0
失败:-1,并设置errno号
注意对错误的处理方式:
如果错误是file exist时,注意加判断,如:if(errno == EEXIST)
注意:函数只是在路径下创建管道文件,往管道中写的数据依然是写在内核空间中
练习:
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>//引用错误号头文件
int main(int argc, char const *argv[])
{
if (mkfifo("./fifo", 0777) < 0)
{
if (errno == EEXIST) //如果错误号信息是已存在则打印提示语句
printf("file exist!\n");
else
{
perror("mkfifo err");
return -1;
}
}
printf("mkfifo success\n");
return 0;
}
3> 注意事项
(1)只写方式打开会阻塞,一直到另一个进程把读端打开
(2)只写方式打开会阻塞,一直到另一个进程把写端打开
(3)可读可写,如果管道中没有数据,读会阻塞
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
char buf[32] = "";
if (mkfifo("./fifo", 0777) < 0)
{
if (errno == EEXIST) // 如果错误号信息是已存在则打印提示语句
printf("file exist!\n");
else
{
perror("mkfifo err");
return -1;
}
}
printf("mkfifo success\n");
// 打开文件
int fd = open("./fifo", O_RDONLY);//只读方式会阻塞
// int fd = open("./fifo", O_WRONLY);//只写方式会阻塞
// int fd = open("./fifo", O_RDWR);//可读可写方式不会阻塞
// 读写操作
write(fd, "hello", 5);//向管道写 hello
read(fd, buf, 32);//从管道中读取数据到buf中
printf("%s\n", buf);//打印buf中内容
return 0;
}
练习:通过两个进程实现 cp功能
一个进程读取源文件中的内容放到管道中,另一个进程读取管道中的内容写到目的文件中
读进程代码:
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
if (mkfifo("./fifo", 0777) < 0) // 创建管道文件
{
if (errno == EEXIST)
printf("fifo exist\n");
else
{
perror("mkfifo err\n");
return -1;
}
}
printf("fifo success\n");
int fd, fd1;
char buf[32];
// 读
fd = open("fifo", O_WRONLY);//以只写方式打开管道文件
fd1 = open(argv[1], O_RDONLY);//以只读方式打开源文件
int n;//保存读取的数据个数
//循环读取源文件中的数据,先放到数组buf中,再从buf中读取放到管道中
while (n = read(fd1, buf, 32))
write(fd, buf, n);
//关闭文件描述符
close(fd);
close(fd1);
return 0;
}
写进程代码:
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
// 重复执行创建管道操作不会出错,因为当官到文件第一次被创建后,后面在创建不会影响而是会打印 EEXIST 的错误,提示已经存在
if (mkfifo("./fifo", 0777) < 0) // 创建管道文件
{
if (errno == EEXIST)
printf("fifo exist\n");
else
{
perror("mkfifo err\n");
return -1;
}
}
printf("fifo success\n");
int fd, fd2;
char buf[32];
// 写
fd = open("fifo", O_RDONLY);//以只读方式打开管道文件
fd2 = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0777);//以只写方式打开目的文件
int n;
//循环读取管道中的数据,先放到数组buf中,再从buf中读取放到目的文件中
while (n = read(fd, buf, 32))
write(fd2, buf, n);
close(fd);
close(fd2);
return 0;
}
一起执行完毕
4> 有名管道和无名管道的区别
无名管道 | 有名管道 | |
使用场景 | 具有亲缘关系的进程间 | 不相干的进程间也可以使用 |
特点 | 半双工通信 固定的读端fd[0]和写端fd[1],看做一种特殊的文件可以通过文件操作 | 在文件系统中会存在管道文件,数据放在内核空间中,通过文件IO进行操作遵循先进先出,不支持lseek操作 |
函数 | pipe(),直接read/write | mkfifo(),先打开open,再读写read/write |
读写特性 | 当管道中无数据会度阻塞 当管道中写满时会写阻塞 关闭读端,往管道中写会管道破裂 | 只写方式下打开管道会阻塞,直到另一个进程把读端打开 只读方式下打开管道会阻塞,直到另一个进程把写端打开 可读可写方式下打开管道,如果管道中无数据会读阻塞 |
【2】信号
1》概念
(1)信号是在软件层次上对中断机制的一种模拟,是一种异步通信方式
(2)信号可以直接进行用户空间进程和内核进程之间的交互,内核进程也可以利用它来通知用户空间进程发生了哪些系统事件
(3)如果该进程当前并未处于执行态,则该信号就又内核保存起来,直到该进程恢复执行再传递给它;如果一个信号被进程设置为阻塞,则该信号的传递被延迟,直到其阻塞被取消时才被传递给进程。
信号的生命周期
2》信号的响应方式
(1)忽略信号:对信号不做任何处理,但是有两个信号不能忽略:即SIGKILL及SIGSTOP.
(2)捕捉信号:定义信号处理函数,当信号发生时,执行相应的处理函数
(3)执行缺省操作:Linux对每种信号都规定了默认操作
3》信号种类
一些比较常用的信号:
SIGINT(2):中断信号,Ctrl-C 产生,用于中断进程
SIGQUIT(3):退出信号, Ctrl-\ 产生,用于退出进程并生成核心转储文件
SIGKILL(9):终止信号,用于强制终止进程。此信号不能被捕获或忽略。
SIGALRM(14):闹钟信号,当由 alarm() 函数设置的定时器超时时产生。
SIGTERM(15):终止信号,用于请求终止进程。此信号可以被捕获或忽略。termination
SIGCHLD(17):子进程状态改变信号,当子进程停止或终止时产生。
SIGCONT(18):继续执行信号,用于恢复先前停止的进程。
SIGSTOP(19):停止执行信号,用于强制停止进程。此信号不能被捕获或忽略。
SIGTSTP(20):键盘停止信号,通常由用户按下 Ctrl-Z 产生,用于请求停止进程。
4》 函数接口
1> 信号发送和挂起
#include <signal.h>
int kill(pid_t pid, int sig);
功能:信号发送
参数:pid:指定进程
sig:要发送的信号
返回值:成功 0
失败 -1
int raise(int sig);
功能:进程向自己发送信号
参数:sig:信号
返回值:成功 0
失败 -1
相当于:kill(getpid(), sig);
int pause(void);
功能:用于将调用进程挂起,直到收到被捕获处理的信号为止。
练习:
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
//kill(getpid(), SIGKILL); //给进程发送信号,此例子是给当前进程发送SIGKILL信号
// raise(SIGKILL); //给当前进程发送SIGKILL信号,等同于kill(getpid(), SIGKILL);
// while (1);
pause(); //将进程挂起,作用类似死循环但是不占用CPU
return 0;
}
2> 定时器 alarm
man 2 alarm
unsigned int alarm(unsigned int seconds)
功能:在进程中设置一个定时器。当定时器指定的时间到了时,它就向进程发送SIGALARM信号。
参数:seconds:定时时间,单位为秒
返回值:如果调用此alarm()前,进程中已经设置了闹钟时间,则返回上一个闹钟时间的剩余时间,否则返回0。
注意:一个进程只能有一个闹钟时间。如果在调用alarm时已设置过闹钟时间,则之前的闹钟时间被新值所代替。
常用操作:取消定时器alarm(0),返回旧闹钟余下秒数。
系统默认对SIGALRM(闹钟到点后内核发送的信号)信号的响应: 如果不对SIGALRM信号进行捕捉或采取措施,默认情况下,闹钟响铃时刻会退出进程。
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
printf("%d\n", alarm(10)); //设定闹钟5秒后发送闹钟信号
sleep(1); //睡眠1秒,此时闹钟还剩9秒
printf("%d\n", alarm(3)); //打印剩余的9秒,设新闹钟3秒后发送闹钟信号
pause(); //为了不让进程结束,等待SIGALRM信号产生,产生之后结束当前进程
return 0;
}
3> 信号处理函数 signal()
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
功能:信号处理函数
参数:signum:要处理的信号
handler:信号处理方式
SIG_IGN:忽略信号 (忽略 ignore)
SIG_DFL:执行默认操作 (默认 default)
handler:捕捉信号 (handler为函数名,可以自定义)
void handler(int sig){} //函数名可以自定义, 参数为要处理的信号
返回值:成功:设置之前的信号处理方式
失败:-1
补充:typedef给数据类型重命名
#include <stdio.h>
//给普通数据类型int重命名
typedef int size4;
//给指针类型int* 重命名
typedef int *int_p;
//给数组类型int [10]重命名
typedef int intArr10[10];
//给函数指针void (*)()重命名
typedef void (*fun_p)();
void fun()
{
printf("fun\n");
}
int main(int argc, char const *argv[])
{
size4 a = 10; //相当于int a=10;
int_p p = &a; //相当于int* p=&a;
intArr10 arr = {1, 2, 3}; //相当于int arr[10]={1,2,3};
fun_p fp = fun; //相当于 void (*fp)()=fun;
printf("%d\n", *p);
printf("%d\n", arr[0]);
fp();
return 0;
}
总而言之,定义变量的变量名写在哪里,用typedef给数据类型重命名的新名字就写在哪里。然后使用新名字定义变量的格式直接就可以为:新名字 变量名;
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void handler(int sig) //参数sig代表要处理的信号
{
if (sig == SIGINT)
printf("ctrl C: %d\n", sig);
else if (sig == SIGTSTP)
printf("ctrl Z: %d\n", sig);
}
int main(int argc, char const *argv[])
{
signal(SIGINT, SIG_IGN); //对SIGINIT信号设置忽略方式处理
//signal(SIGINT,SIG_DFL); //对SIGINIT信号设置缺省方式处理,也就是默认操作
signal(SIGINT, handler); //对SIGINIT信号设置捕捉方处理,也就是自定义处理方式
signal(SIGTSTP, handler);
//while (1); //为了让进程不要结束,因为等到信号真的来才能验证,不然进程就结束了
pause(); //收到被捕获处理的信号时会结束挂起
return 0;
}
【3】共享内存
1》特点
(1)共享内存是一种最为高效的进程间通信方式,进程可以直接读写内存,而不需要任何数据的拷贝。
(2)为了在多个进程间交换信息,内核专门留出了一块内存区,可以由需要访问的进程
将其映射到自己的私有地址空间。进程就可以直接读写这一内存区而不需要进行数据的拷贝,从而大大提高的效率。
(3)由于多个进程共享一段内存,因此也需要依靠某种同步机制,如互斥锁和信号量等
2》步骤
1> 创建key值
2> 创建或打开共享内存
3> 映射共享内存到用户空间
4> 撤销映射
5> 删除共享内存
3》 函数接口
key_t ftok(const char *pathname, int proj_id);
功能:创建出来的具有唯一映射关系的一个key值,帮助操作系统用来标识一块共享内存
参数:Pathname:已经存在的可访问文件的名字
Proj_id:一个字符(因为只用低8位)
返回值:成功:key值
失败:-1
int shmget(key_t key, size_t size, int shmflg);
功能:创建或打开共享内存
参数:key 键值
size 共享内存的大小
shmflg IPC_CREAT|IPC_EXCL|0777
返回值:成功 shmid
出错 -1
注意对错误的处理方式:
如果错误是file exist光打开共享内存不用设IPC_CREAT|IPC_EXCL了,加判断,如:if(errno == EEXIST)
void *shmat(int shmid,const void *shmaddr,int shmflg); //attaches
功能:映射共享内存,即把指定的共享内存映射到进程的地址空间用于访问
参数:shmid 共享内存的id号
shmaddr 一般为NULL,表示由系统自动完成映射
如果不为NULL,那么有用户指定
shmflg:SHM_RDONLY就是对该共享内存只进行读操作
0 可读可写
返回值:成功:完成映射后的地址,
出错:-1(地址)
用法:if((p = (char *)shmat(shmid,NULL,0)) == (char *)-1)
int shmdt(const void *shmaddr); //detaches
功能:取消映射
参数:要取消的地址
返回值:成功0
失败的-1
int shmctl(int shmid,int cmd,struct shmid_ds *buf); //control
功能:(删除共享内存),对共享内存进行各种操作
参数:shmid 共享内存的id号
cmd
IPC_STAT 获得shmid属性信息,存放在第三参数
IPC_SET 设置shmid属性信息,要设置的属性放在第三参数
IPC_RMID:删除共享内存,此时第三个参数为NULL即可
buf shmid所指向的共享内存的地址,空间被释放以后地址就赋值为null
返回值:成功0
失败-1
用法:shmctl(shmid,IPC_RMID,NULL);
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <errno.h>
int main(int argc, char const *argv[])
{
int shmid;
key_t key;
char *p;
key = ftok("shm.c", 'a');
if (key < 0)
{
perror("key err");
return -1;
}
printf("key: %#x\n", key);
//打开或创建共享内存
shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0777); //如果共享内存不存在则创建,存在则返回-1
if (shmid <= 0)
{
if (errno == EEXIST) //如果共享内存已存在则,直接打开
shmid = shmget(key, 128, 0777); //直接打开已有的共享内存并且获得共享内存id
else
{
perror("shmget err");
return -1;
}
}
printf("shmid: %d\n", shmid);
//映射共享内存
p = (char *)shmat(shmid, NULL,0);
if(p == (char *)-1)
{
perror("shmat err");
return -1;
}
//操作共享内存
scanf("%s",p);
printf("%s\n", p);
//取消映射
shmdt(p);
//删除共享内存
shmctl(shmid,IPC_RMID,NULL);
return 0;
}
进程间通信:
4》命令
ipcs -m :查看系统中的共享内存
ipcrm -m shmid:删除共享内存
ps: 可能不能直接删除掉还存在进程使用的共享内存。
这时候可以用ps -ef对进程进行查看,kill掉多余的进程后,再使用ipcs查看。
标签:int,间通信,管道,fd,IO,进程,include,buf From: https://blog.csdn.net/dghbs/article/details/141724910今天的分享就到这里结束啦,如果有哪里写的不好的地方,请指正。
如果觉得不错并且对你有帮助的话点个关注支持一下吧!