1 一个进程是 ( C )。
A、处理机一次或多次执行的一个程序。
B、 一个独立的程序 +数据集。
C、PCB 结构与程序和数据的组合。
D、一个独立的程序。
2 一个进程调用 wait 或 waitpid 函数，可能产生 3 中情况，下列不属于这 3 种
情况的是 ( D )。
A、如果所有子进程都还在运行，进程挂起。
B、如果恰有子进程结束，它的终止状态字正等待父进程提取，立即得到该
终止状态字并返回，其返回值为该子进程的进程号。
C、waitpid，如果该进程没有子进程，参3指定了WNOHANG，返回0。
D、如果该进程没有子进程，立即返回，返回值为 0。
3 返回调用进程的进程标识号的系统函数是 ( A )。
A、 getpid
B、getpgrp
C、getppid
D、setpid
4 程序和进程是两个不同的概念，以下不能描述这个观点的是 ( B )。
A、程序指出了处理器执行操作的步骤，而进程是一个程序在一个数据集合上
的一次执行。
B、同一个程序运行 10 次，产生的是同一个进程。
C、进程是动态的，是程序的执行过程。
D、多个不同的进程可以包含相同的程序。
5 Fork 函数在父进程中的返回值是 ( A )。
A、创建的子进程的进程标识号
B、0
C、-1
D、1
6 在 Linux 中，下列不属于正常结束进程的方法是 ( D )。
A、在 main 函数中调用 return 。
B、调用 exit 函数 。
C、调用_exit 函数 。
D、调用 abort函数。
二. 多选题
1 哪种进程之间的通信，数据不可以重复读（BC ）
A、共享内存映射进程间通信
B、fifo
C、管道
D、文件

1 下述是Linux下多线程编程常用的pthread库提供的函数名和意义，说法不正确的是？D

A、pthread_create 创建一个线程
B、pthread_join用来等待一个线程的结束
C、pthread_mutex_init 初始化一个线程互斥锁
D、pthread_exit杀死一个线程

2 对线程函数来说，说法正确的是：A
A、pthread_create中参数arg是传递给start_routine函数的参数
B、pthread_join函数用于结束线程，其参数是线程的返回值
C、 pthread_exit函数用于退出另一个线程，参数是另一个线程的ID
D、pthread_cancel函数用于取消当前线程的执行，即退出本线程
3 对互斥锁及条件变量说法不正确的是：D
A、互斥锁保证让每个线程对共享资源按顺序进行原子操作
B、条件变量是让线程睡眠，在符合某种条件时唤醒睡眠的线程
C、条件变量可以让多个线程在某一时间上保持同步
D、在使用条件变量时，互斥锁会失去作用，所以是否有互斥锁关系不重要
4 以下说明正确的是：B
A、进程和线程都可以由CPU直接执行的指令流，所以进程和线程没有区别
B、线程是一个独立的指令流，是在进程中被创建的，随进程的关闭而关闭
C、进程和线程都是一个程序，是执行程序的过程，拥有完整的资源，都有自己的数据段、代码段等
D、一个回调函数就是一个线程，所以多线程必须有多个回调函数实现
5线程A SendMessage给线程B，线程B处理该消息时又SendMessage给线程A，会出现：B
A、死锁
B、继承执行
C、线程A停止响应
D、线程B停止响应
linux文件系统通常由四部分组成：引导块，超级块，索引节点和 B 。
A、文件块
B、数据块
C、索引块
D、目录块
2 任何进程在运行时默认打开的三个流对象，都有相应的文件描述符，标准文件描述符定义标准输入设备的值为 A 。
A、0
B、1
C、2
D、3
3 系统调用的函数原型int open(const char *pathname, int flags)，flag值中 C 表示以读写的方式打开文件。
A、O_RDONLY
B、O_WRONLY
C、O_RDWR
D、O_APPEND
4 系统调用的函数原型int open(const char *pathname, int flags)，flag值中 B 表示若文件存在且为只读或只写成功打开，则将长度截为0。
A、O_APPEND
B、O_TRUNC
C、O_CREAT
D、O_EXCL
5 #include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
int main()
{
int fd,length;
fd=open(“lseek.txt”,O_RDWR);
length=lseek(fd,0,SEEK_END);
printf(“the length os lseek is %d\n”,length);
close(fd);
return 0;
}
此行代码length=lseek(fd,0,SEEK_END);中的length的值表示A 。
A、文件lseek.txt的大小
B、调整lseek.txt指针位置到文件的开头
C、调整lseek.txt指针位置到文件的中间
D、调整lseek.txt指针位置到文件的第二个字节
6 使用下列函数调用int fcntl(int fd, int cmd);来实现文件描述符的复制，cmd参数应使用哪一个？A
A、F_DUPFD
B、FD_CLOEXEC
C、F_GETFD
D、F_SETFD
7 阅读程序填空：如果想要获取文件的大小，空白处应该填写以下哪个答案。A
#include<stdio.h>
#include<unistd.h>
#include<sys/stat.h>
int main(int argc, char *argv[])
{
struct stat statBuf;
if(stat(argv[1],&statBuf)<0)
{
perror(“stat”);
}
else
{
printf(“the size of file is %ld”, );
}
return 0;
}
A、 statBuf.st_size
B、statBuf.st_ino
C、statBuf.st_ctime
D、 statBuf.st_atime
8 在创建文件和目录时候，有默认权限。如果umask值为0022，则文件的默认权限为 B 。
A、0666
B、0644
C、 0777
D、0755
9 #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int main (void)
{
int fd; if((fd=open(“tempfile”,O_WRONLY|O_CREAT|O_TRUNC,0700))< 0)
{
perror(“open”);
exit(1);
}
if((link(“tempfile”,“hardlink”))==-1)
{
perror(“open”);
exit(1);
}
struct stat statBuf;
fstat(fd, &statBuf);
printf(“link num:%ld\n”, statBuf.st_nlink);
sleep(3);
if(unlink(“tempfile”) < 0)
{
perror(“unlink”);
exit(1);
}
fstat(fd, &statBuf);
printf(“unlink ,num:%ld\n”, statBuf.st_nlink);
return 0;
}

执行程序，代码输出结果为 A 。
A、link num:2
unlink ,num:1
B、link num:2
unlink ,num:2
C、link num:3
unlink ,num:2
D、link num:1
unlink ,num:1
10 获取目录的系统调用函数为B 。
A、chdir()
B、getcwd()
C、opendir
D、closedir

1. 以下哪种方式属于异常终止一个进程（D ）
   A从main函数返回。
   B调用exit。
   C最后一个线程从其启动例程返回。
   D接到一个信号并终止。
2. 下列命令哪个是创建线程私有数据命令（A）
   A pthread_key_create() B pthread_setspecific()
   C pthread_getspecific() D pthread_key_delete();
3. 下面哪种通信方式适用于不同机器之间的进程通信。（D ）
   A．消息队列 B．共享内存 C．信号量 D．套接字
4. 创建或打开消息队列的函数为（A ）
   A．msgget() B．msgsnd() C．msgrcv() D. msgctl()
5. 什么是进程？进程资源由哪两部分组成？
   进程是可并发执行的程序在某个数据集合上的一次计算活动，也是操作系统进行资源分配和调度的一个独立单位。
   进程资源由内核空间资源（PCB控制块） 和 用户空间资源
6. linux中通过调用waitpid()函数得到进程的退出信息，该函数原型为
   pid_t waitpid(pit_t pid, int *statloc, int options);当第一个参数pid取值为-1时，表示（A）
   A等待任一子进程退出,相当于 wait()。
   B等待进程组ID与调用进程组ID相同的任一子进程。
   C只等待进程ID等于PID的子进程。
   D等待指定进程组中的进程，该进程组id等于 pid的绝对值。
7. pid_t fork() 返回值的意义？
   若执行成功，父进程中将返回子进程(新创建的进程)的PID，类型为pid_t,
   子进程将返回0，以区别父子进程
   若执行失败，则在父进程中返回-1，错误原因存储在errno中
8. Linux环境中使用kill函数向进程或进程组发送信号。Kill函数原型为
   int kill（pid_t pid, int signo）；当第一个参数pid>0时，表示（ A ）
   A发送信号给进程ID为pid的进程；
   B发送信号给进程组ID和该进程相同的进程；
   C发送信号给进程组内进程ID为pid的绝对值的进程；
   D发送信号给系统的所有进程；
9. 共享主存基本操作（ A ）将共享主存区映射到进程虚拟地址空间。
   A shmat() B shmdt() C shmctl() D shmget()
10. 修改消息队列状态信息的命令是（B）
    A msgsnd() B msgctl() C msgrcv() D msgget()
11. linux中把分区和目录对应的过程叫做 挂载 。
12. 信号是在软件层次上对 中断 机制的一种模拟， 是一种异步通信方式。
13. 用GCC编译过程可以被细分为四个阶段： 预处理，编译，汇编，连接 。
14. 编译有线程的文件要加 -lpthread 参数。
15. 父进程等待子进程的结束，可以使用的函数是 wait( ) 和 waitpid( ) 。
16. linux主要有两个信号安装函数，分别是signal( ),sigaction( )
17. Linux操作系统内核由 C和汇编 编写完成。
18. 使用gdb调试程序时，，next和step命令的作用？
    next:单步运行，不进入函数内部;setp单步运行，进入函数内部
19. 目录 /boot 下存放linux操作系统启动时所要用到的程序
20. Linux 系统的设备文件分为三类？
    字符设备文件、块设备文件和网络设备文件
21. Linux 中采用“一对一”的线程机制，也就是一个用户线程对应一个 内核线程 。
22. vim三种模式：在命令模式下按下 ： 就进入了底线命令模式。
23. 标准I/O提供了三种类型的缓冲，分别是？
    全缓冲，行缓冲，不带缓冲
24. linux文件系统由四部分组成， 用于存放文件的控制信息。
25. 一个完整的信号生命周期包含4个重要的事件，这4个重要事件分别是？
    信号诞生 信号在进程中注册 信号在进程中注销 信号处理函数执行完毕
26. 互斥锁只有两种状态，即？开锁和上锁
27. 线程本身调用 pthread_exit() 函数可以退出线程。
28. 向消息队列发送消息的函数是 msgrcv() 。

29. stat    系统调用可以根据文件描述符来操作文件特性。
    

30. Valgrind包括很多工具， Memcheck 是valgrind应用最广泛的工具，一个重量级的内存检查器，能够发现开发中绝大多数内存错误使用情况， Cachegrind 是主要用来检查程序中缓存使用出现的问题。
31. 信号发送函数中， setitimer() 用于设置定时器，当计时时间到达时，向进程发送SIGALRM信号。
32. 在标准IO库中，rewind函数作用？ 将文件流指针指向文件起始位置
33. c语言中没有明确给定初值的全局变量和静态变量存放在哪儿？未初始化数据区
34. 函数geteuid()用于得到进程的？用户有效UID
35. 当一个线程的属性设置为 分离状态 ，该线程结束时立即释放它所占有的系统资源。
36. 父进程调用wait() 可能出现的三种情况？（5分）。
37. 当有子进程退出时wait返回子进程的pid并且获取到子进程的退出状态
38. 当没有子进程退出时 父进程将阻塞等待子进程退出
39. 当没有子进程时，wait返回-1
40. 什么是孤儿进程?谁负责回收孤儿进程的内核空间资源？
    父进程先于子进程结束 则子进程称为孤儿进程 由init 0接管并回收其内核资源
41. 僵尸进程是什么？如何消灭僵尸进程？
    僵尸进程 子进程结束但是父进程未回收其内核资源， 可以通过调用wait()或waitpid() 或者使其成为孤儿进程 由操作系统回收其内核资源
42. 简述进程对可靠信号和不可靠信号的处理过程。
    不可靠信号 不支持排队 如果在进程屏蔽信号时 给其发送多个不可靠信号，在取消屏蔽后只会接收到一个
    可靠信号 支持排队 如果在进程屏蔽信号时 发送多个信号，在取消屏蔽后会按照先后顺序接收到所有可靠信号
43. 在标准IO库中，rewind函数作用？
    将文件内部的位置指针重新指向一个流（数据流/文件）的开头
44. 一个完整的信号生命周期包含4个重要的事件，这4个重要事件分别是？
    信号诞生；信号在进程中注册完毕；信号在进程中的注销完毕；信号处理函数执行完毕
45. 使用gdb调试程序时，next和step命令的作用？
    step 就是单步执行，遇到子函数就进入并且继续单步执行；
    next 是在单步执行时，在函数内遇到子函数时不会进入子函数内单步执行，而是将子函数整个执行完再停止，也就是把子函数整个作为一步
46. 什么是进程？进程资源由哪两部分组成？
    进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础
    进程资源包括内核空间进程资源和用户空间进程资源
47. 在进程中，return和exit() 的区别？
    return是语言级别的，它表示了调用堆栈的返回；而exit是系统调用级别的，它表示一个进程的结束。
    在main函数里，return(0)和exit(0)是一样的，子函数用return返回，而子进程用exit退出，调用exit时要调用一段终止处理程序，然后关闭所有I/O流
48. 简述进程对可靠信号和不可靠信号的处理过程。
    如果进程在屏蔽某个信号的时间内，0其他进程多次向其发送同一个信号，不可靠信号只有一次未决记录，当进程解除屏蔽后，该信号只会被捕捉一次；而可靠信号操作系统会记录所有的发送，当进程解除屏蔽后，操作系统会捕捉对等次数。
49. 简单介绍一下信号的定义及其分类。
    信号是表示消息的物理量，是运载消息的工具
    信号是软件中断，是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的
    分类：确定信号和随机信号；连续信号和离散信；周期信号和非周期信号；能量信号与功率信号；因果信号与反因果信号；实信号与复信号
50. 简单介绍一下匿名管道及其特点。
    匿名管道用于进程之间通信，且仅限于本地父子进程之间通信，结构简单。
    1.只提供单向通信，也就是说，两个进程都能访问这个文件，假设进程1往文件内写东西，那么进程2 就只能读取文件的内容。
    　　2.只能用于具有血缘关系的进程间通信，通常用于父子进程建通信
    　　3.管道是基于字节流来通信的
    　　4.依赖于文件系统，它的生命周期随进程的结束结束（随进程）
    　　5。其本身自带同步互斥效果
51. 请解释一下有名管道和匿名管道的区别?
    匿名管道是由pipe函数创建 并打开的
    命名管道是由mkfifo函数创建 的 ，打开用open命名 管道和匿名管道唯一的区别就是在创建的打开，一旦这些工作完成后，它们有相同的意义。
52. 什么是线程？进程和线程的区别？
    线程是操作系统能够进行运算调度的最小单位。
    进程是运行中的程序，线程是进程的内部的一个执行序列
    进程是资源分配的单元，线程是执行行单元
    进程间切换代价大，线程间切换代价小
    进程拥有资源多，线程拥有资源少
    多个线程共享进程的资源
53. Please describe the difference of signal() and sigaction() in brief
    signal在调用handler之前先把信号的handler指针恢复；sigaction调用之后不会恢复handler指针，直到再次调用sigaction修改handler指针。
    这样，(1)signal就会丢失信号，而且不能处理重复的信号，而sigaction就可以。因为signal在得到信号和调用handler之间有个时间把handler恢复了，这样再次接收到此信号就会执行默认的handler。（虽然有些调用，在handler的以开头再次置handler，这样只能保证丢信号的概率降低，但是不能保证所有的信号都能正确处理）
    2、signal在调用过程不支持信号block；sigaction调用后在handler调用之前会把屏蔽信号（屏蔽信号中自动默认包含传送的该信号）加入信号中，handler调用后会自动恢复信号到原先的值。
    （2）signal处理过程中就不能提供阻塞某些信号的功能，sigaction就可以阻指定的信号和本身处理的信号，直到handler处理结束。这样就可以阻塞本身处理的信号，到handler结束就可以再次接受重复的信号。

1.创建文件file1，写入字符串“abcdefghijklmn”；
2.创建文件file2，写入字符串“ABCDEFGHIJKLMN”;
3.读取file1中的内容，写入file2，使file2中的字符串内容为“abcdefghijklmn ABCDEFGHIJKLMN”
创建file1，file2 文件
IO_open.c 源码
/*************************************************************************
> File Name: IO_open.c

作者:YJK
Mail: 745506980@qq.com
Created Time: 2019年09月08日 星期日 19时58分23秒
************************************************************************/
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
int main(int argc,char *argv[])
{
int IO_OPEN,IO_OPEN_1;//文件描述符
int write_num1,write_num2=-1;
char *buf=“abcdefghijklmn”;
char *buf2=“ABCDEFGHIJKLMN”;
if(argc<3)
{
printf(“ERROR！number<3\n”) ;
return -1;
}
IO_OPEN=open(argv[1],O_CREAT|O_RDWR,0755);
if(IO_OPEN==-1)
{
perror(“open”);
return -1;
}
IO_OPEN_1=open(argv[2],O_CREAT|O_RDWR,0755);
if(IO_OPEN_1==-1)
{
perror(“open”);
return -1;
}
write_num1=write(IO_OPEN,buf,strlen(buf));
write_num2=write(IO_OPEN_1,buf2,strlen(buf2));
close(IO_OPEN);
close(IO_OPEN_1);
return 0;
}

实现file1中的字符串写入file2中
IO_file_rw.c 源码
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
int main(int argc,char argv[])
{
int fd,fd2=-1;
int rd_num,rd_num2,wt_num=-1;
char buf[128]={0};
char buf1[128]={0};
if(argc<3)
{
printf(“ERROR!\n”);
return -1;
}
if((fd=open(argv[1],O_RDONLY))-1)//以读写方式打开file1
{
perror(“open”);
return -1;
}
if((fd2=open(argv[2],O_RDWR))-1)//打开file2
{
perror(“open”);
return -1;
}
rd_num=read(fd,buf,128);
rd_num2=read(fd2,buf1,128);
/ 先将file2 文件中的字符串向后移动rd_num(file中的字符串长度)个位置*/
lseek(fd2,rd_num,SEEK_SET);
write(fd2,buf1,rd_num2);
lseek(fd2,0,SEEK_SET);
write(fd2,buf,rd_num);
/* lseek(fd2,0,SEEK_SET); //先将file1中的字符串写入file2 再将file2中的字符串追加到后面
write(fd2,buf,rd_num);
write(fd2,buf1,rd_num2);*/
close(fd2);
close(fd);
return 0;
}

实验二
 编写代码，完成以下功能：
 1.创建新文件，该文件具有用户读写权限。
 2.采用dup/dup2/fcntl复制一个新的文件描述符，通过新文件描述符向文件写入“class_name”字符串；
 3.通过原有的文件描述符读取文件中的内容，并且打印显示；

IO_file.c文件源码

/************************************************************************
> File Name: IO_file.c
> 作者:YJK
> Mail: 745506980@qq.com
> Created Time: 2019年10月10日 星期四 20时50分55秒
***********************************************************************/
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
#include<sys/stat.h>
int main(int argc,char *argv[])
{
int fd=-1;
int fd2=-1;//新的文件描述符
int wrnum,rdnum=0;
char *buf=“移动一班–袁俊珂–1815925428\n”;
char buf1[128]={0};
umask(0);//修改umask值
fd=open(argv[1],O_CREAT|O_RDWR,0600);
if(fd==-1)
{
perror(“open”);
return -1;
}
//复制文件描述符
fd2=dup(fd);//选取未被使用的最小的文件描述法
// fd2=dup2(fd,5);//使用指定的文件描述符 如果该文件描述符已被使用则关闭该文件描述符 重新使用
// fd2=fcntl(fd,F_DUPFD,1);//实现文件描述符复制，选择大于等于1的未被使用的文件描述符
wrnum=write(fd2,buf,strlen(buf));//使用新的文件描述符写入字符串
if(wrnum0)//如果写入失败
{
perror(“write”);
return -1;
}
//此时文件指针位于文件末尾
lseek(fd,0,SEEK_SET);//将文件指针指向文件开始
rdnum=read(fd,buf1,128);//使用老的文件描述符将文件中的信息读取到buf1中
if(rdnum0)
{
perror(“read”);
return -1;
}
printf("%s",buf1);//打印出读取的字符串
close(fd);
close(fd2);
return 0;
}

 编写程序完成以下功能：
 1.递归遍历/home目录，打印出所有文件和子目录名称及节点号。
 2.判断文件类型，如果是子目录，继续进行递归遍历，直到遍历完所有子目录为止。

IO_dirread.c源码
/************************************************************************
> File Name: IO_dirread.c
> 作者:YJK
> Mail: 745506980@qq.com
> Created Time: 2019年10月13日 星期日 20时40分56秒
***********************************************************************/
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<dirent.h>
#include<sys/stat.h>
#include<string.h>
int main(int argc,char *argv[])
{
int dir_read(const char *str);
dir_read(argv[1]);
return 0;
}
int dir_read(const char * str)
{
struct stat buf;
struct dirent *dirp=NULL;
DIR *dir=NULL;
char BUF[512]={0};
if((dir=opendir(str))NULL)
{
perror(“opendir”);
return -1;
}
while((dirp=readdir(dir))!=NULL)
{
sprintf(BUF,"%s%s%s",str,"/",dirp->d_name);//获取目录的绝对路径
if(dirp->d_name[0]’.’)//跳过隐藏文件
continue;
if(stat(BUF,&buf)==-1)//需要使用绝对路径
{
perror(“stat”);
return -1;
}
if(S_ISDIR(buf.st_mode))//如果当前文件为目录，则递归查看其子目录
{
printf("%s %ld\n",BUF,dirp->d_ino);
dir_read(BUF);
}
else
{
printf("%s %ld \n",dirp->d_name,dirp->d_ino);
}
}
closedir(dir);
}

实验三，第二题，第三题
实验三
 创建子进程
 1.在子进程中打开文件file1，写入自己的“班级_姓名_学号”，
 2.父进程读取file1中的内容，并且打印显示。
 3.在父进程中获取已经结束的子进程的状态信息，打印该信息，并且打印结束的子进程的进程号。

/************************************************************************
> File Name: IO_ptest1.c
> 作者:YJK
> Mail: 745506980@qq.com
> Created Time: 2019年10月17日 星期四 20时56分57秒
***********************************************************************/
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<wait.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
int main(int argc,char *argv[])
{
int fd,fd2=-1;
int i;
pid_t pid,pid_wait=-1;
int status;
char *buf=“移动一班-袁俊珂-1815925428”;
char BUF[128]={0};
if((pid=fork())-1)
{
perror(“fork”);
exit(EXIT_FAILURE);
}
if(pid0)
{
if((fd=open(“myfile”,O_CREAT|O_RDWR,0777))-1)//在子进程中打开文件
{
perror(“open”);
exit(EXIT_FAILURE);
}
if(write(fd,buf,strlen(buf))-1)
{
perror(“write”);
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
else
{
pid_wait=wait(&status);//使父进程处于阻塞状态
if((WIFEXITED(status)))//判断子进程是否正常终止
{
printf(“normal exit,return value:%d\n”,WEXITSTATUS(status));
}
printf(“child PID: %d\n”,pid_wait);
if((fd=open(“myfile”,O_RDONLY))-1)
{
perror(“parent open”);
exit(EXIT_FAILURE);
}
if(read(fd,BUF,128)-1)//读取文件
{
perror(“read”);
exit(EXIT_FAILURE);
}
printf(“read myfile: %s\n”,BUF);
close(fd);
exit(EXIT_SUCCESS);
}
}

实验四，第三题

1. 编写程序实现以下功能：
   利用有名管道文件实现进程间通信，要求
   写进程向有名管道文件写入10次“hello world”；
   读进程读取有名管道文件中的内容，并依次打印。

创建有名管道源码
/************************************************************************
> File Name: IO_fifo.c
> 作者:YJK
> Mail: 745506980@qq.com
> Created Time: 2019年10月27日 星期日 21时39分25秒
**********************************************************************/
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/stat.h>
/
*有名管道实现非亲缘关系的进程通信
*进程一 向有名管道中写入数据，如果进程二不已可读方式打开管道则进程一阻塞，直到进程二以可读方式打开管道

• */
  int main(int argc,char *argv[])
  {
  int fd;
  if(mkfifo(“FIFO”,0777)==-1)//创建有名管道
  {
  perror(“mkfifo”);
  exit(EXIT_FAILURE);
  }
  printf(“管道FIFO创建成功!\n”);
  return 0;
  }

写进程 源码

/************************************************************************
> File Name: IO_fifo_fc.c
> 作者:YJK
> Mail: 745506980@qq.com
> Created Time: 2019年10月30日 星期三 15时45分35秒
***********************************************************************/
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>

/*
*写进程

• */
  int main(int argc,char *argv[])
  {
  int write_fd;
  char buf[]=“hello world”;
  if((write_fd=open(“FIFO”,O_WRONLY))-1)
  {
  perror(“open”);
  exit(EXIT_FAILURE);
  }
  for(int i=0;i<10;i++)
  {
  if(write(write_fd,buf,sizeof(buf)-1)-1)
  {
  perror(“write”);
  exit(EXIT_FAILURE);
  }
  usleep(10);
  }
  exit(EXIT_SUCCESS);
  }

2. 读进程
   /************************************************************************

   File Name: IO_fifo_fc.c
   作者:YJK
   Mail: 745506980@qq.com
   Created Time: 2019年10月30日 星期三 15时45分35秒
   **********************************************************************/
   #include<stdio.h>
   #include<fcntl.h>
   #include<unistd.h>
   #include<stdlib.h>
   #include<string.h>
   /
   *读进程

• */
  int main(int argc,char *argv[])
  {
  int read_fd;
  char buf[128]={0};
  if((read_fd=open(“FIFO”,O_RDONLY))-1)
  {
  perror(“open”);
  exit(EXIT_FAILURE);
  }
  for(int i=0;i<10;i++)
  {
  if(read(read_fd,buf,sizeof(buf))-1)
  {
  perror(“write”);
  exit(EXIT_FAILURE);
  }
  printf("%s\n",buf);
  memset(buf,0,sizeof(buf));
  }
  exit(EXIT_SUCCESS);
  }