linux系统编程之三

一）进程1

1) pstree，查看进程树 2）umask，是打印当前程序的umask;为用户文件创建权限掩码; 3) 在shell下输入命令可以运行一个程序，是因为shell进程在读取用户输入命令的命令之后，会调用fork复制出一个新的shell进程； 4) fork创建一个子进程，说是叫子进程，其实就是复制一份父进程，除了进程号不一样；用返回值分辨谁是父，谁是子； 5）refer to as：称作，称为的意思； 6）当子进程结束，会有尸体，这个尸体会由父进程收尸； //子进程和父进程的简单案例： #include<sys/types.h> #include<stdio.h> #include<stdlib.h> #include<errno.h> #include<unistd.h> #include<fcntl.h> int main(int argc, char** argv) { //调用fork会进入内核空间， pid_t pid = fork(); //理论上返回的应该是孩子id,叫childpid,简写为pid; int n; const char* message; if(pid < 0) //子进程从这里就开始判断了 { perror("pid create"); exit(1); } if(pid == 0) { n = 6; message = "son process\n"; } else { n = 3; message = "parent process\n"; } while(n > 0) { n--; printf(message); sleep(1); //调用sleep，程序进入内核空间，当睡眠时间到，程序会进入就绪态，等待cpu调度， //当cpu调度程序的时候，程序又返回用户空间，开始运行程序； } return 0; }

进程二)

1）getpid,getppid的学习，跟fork返回的pid毛关系都没有； ps aux|grep 18878; //ps aux是显示所有进程,grep 18878是搜索是否有这个18878进程； #include<sys/types.h> #include<stdio.h> #include<stdlib.h> #include<errno.h> #include<unistd.h> #include<fcntl.h> int main(int argc, char** argv) { //调用fork会进入内核空间， pid_t pid = fork(); //理论上返回的应该是孩子id,叫childpid,简写为pid; int n; if(pid < 0) //子进程从这里就开始判断了 { perror("pid create"); exit(1); } if(pid == 0) { n = 6; while( n > 0) { n--; //只有在这里可以得到子进程的id，别无它法； printf("child self id is %d, parent = %d\n",getpid(),getppid()); //父进程是fork创建后大于0的那个进程 sleep(1); } } else { n = 3; while( n > 0) { n--; printf("parent self id is %d, parent = %d\n",getpid(),getppid()); //父进程是shell的进程 sleep(1); } } return 0; } 2)循环创建10个子进程案例 #include<sys/types.h> #include<stdio.h> #include<stdlib.h> #include<unistd.h> //重点: 只让父进程循环创建子进程，不能让子进程再次创建子进程； int main(int argc, char** argv) { for(int i = 0; i< 10; i++) { pid_t pid = fork(); if(pid < 0) { perror("pid create"); exit(1); } if(pid == 0) //子进程必须break,否则子子孙孙，无穷匮也； { printf("i is %d,child self id is %d, parent = %d\n",i,getpid(),getppid()); //父进程是fork创建后大于0的那个进程 break; //如果不终止，则创建出来的子进程也会参与循环创建，理论上子进程个数为10*9*...*1这么多个； } else //父进程直接continue; { continue; } } return 0; } //输出结果如下： i is 0,child self id is 19469, parent = 19468 i is 1,child self id is 19470, parent = 19468 i is 2,child self id is 19471, parent = 19468 i is 3,child self id is 19472, parent = 19468 i is 4,child self id is 19473, parent = 19468 i is 5,child self id is 19474, parent = 19468 i is 6,child self id is 19475, parent = 19468 i is 7,child self id is 19476, parent = 19468 i is 8,child self id is 19477, parent = 19468 i is 9,child self id is 19478, parent = 19468

3)gdb多进程调试及exec函数的用法

exec中'l'是list的意思，参数为不定参数； exec中'v'是vector的意思，是定参的,是数组; 'p'是路径的意思； 'e'是环境变量表需要传进来； set follow-fork-mode child/parent //模式设置 当进程调用exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新的程序的启动例程开始执行； execve是真正的可执行程序函数； environ英 [ɪn'vaɪərən] v 包围，环绕; getenv和setenv函数的用法及案例: #include<sys/types.h> #include<stdio.h> #include<stdlib.h> #include<errno.h> #include<unistd.h> #include<fcntl.h> int main(int argc, char** argv) { // extern char** environ; //引入一个已经定义的变量 // for(int i = 0; environ[i] != NULL; i++) // { // printf("%s\r\n",environ[i]); //打印环境变量值 // } char* path = getenv("PATH"); //从当于从父进程的环境变量里面复制了一份，传到这里; printf("[%s]\r\n",path); //加一个中括号，就知道从哪里开始，到哪里结束 setenv("PATH","helllo",1); //主进程环境变量没有改，改的是子进程的环境变量 path = getenv("PATH"); printf("[%s]\r\n",path); return 0; }

4)exec函数的使用方法：

#include<sys/types.h> #include<stdio.h> #include<stdlib.h> #include<errno.h> #include<unistd.h> #include<fcntl.h> int main(int argc, char** argv) { //带'/'，则理解为路径；不带'/',则到$PATH这个路径下找； //第二个不定长参数：主函数传参的所有参数都列出来，注意，第0个参数也要传进来，对与"ls"，来说，就是ls, execlp("/bin/ls", "hahaha", "-a", "-l", NULL); //hahaha这个参数没有任何用，写空也行,hahaha应该是ls参数，尽管它没有作用； perror("exec"); //这句话不会执行 exit(1); return 0; }

5）自己实现流的重定向

读一个文件，实现小写转大写，并把转完的数据写入到另一个文件中，包括5.1和5.2两个程序； 5.1)getchar函数的使用方法； #include<stdio.h> #include<unistd.h> #include<ctype.h> //测试程序： ./target < test.txt //从文件读数据，'<' 相当于重定向; int main(int argc, char** argv) { int ch; while((ch = getchar()) != EOF) //getchar()函数的作用是从计算机终端（一般为键盘）获取一个无符号字符; { putchar(toupper(ch)); } return 0; } 5.2)输入、输出重定向，把标准输入和标准输出重定向为对文件的操作； #include<stdio.h> #include<unistd.h> #include<ctype.h> #include<sys/stat.h> #include<fcntl.h> #include<sys/types.h> #include<stdlib.h> //输入、输出重定向，把标准输入和标准输出重定向为对文件的操作； int main(int argc, char** argv) { if(argc < 2) { printf("cmd + inputfile + outputfile\r\n"); return 1; } int fd = open(argv[1],O_RDONLY); if(fd < 0) { perror("open read"); exit(1); } dup2(fd,0); //修改了标准输入流的位置，相当于0取代了3,言外之意就是，从标准输入得到的数据，改为从打开的文件中读取； close(fd); //因为这里关闭了 fd = open(argv[2],O_WRONLY | O_CREAT, 0644); //如果没有文件，就创建一个 if(fd < 0) { perror("open write"); exit(1); } //下面代码的意思是：按道理应该打印到屏幕上(标准输出)，dup2重定向后,把数据写到文件中去了。 dup2(fd,1); //修改了标准输出流的位置，相当于1取代了3; 因为上面关闭了，所以还是3 close(fd); execl("./upper","./upper",NULL); perror("exec"); return 0; }

6)wait和waitpid的作用，是收尸的

一个程序运行起来，分两块，一个是内核空间，一个是用户空间； defunct 美 [dɪˈfʌŋkt] 失效的 僵尸进程不能被kill -9 ps_id 杀死，相当于是已经死了，杀尸体屁用没有； 如果父进程被杀死了，子进程就会被孤儿院收尸了。 //父进程等待子进程退出的简单案例： #include<sys/types.h> #include<stdio.h> #include<stdlib.h> #include<errno.h> #include<unistd.h> #include<wait.h> int main(int argc, char** argv) { pid_t pid = fork(); //一上电就先创建两个进程； int n = 0; if(pid < 0) { perror("pid create"); exit(1); } if(pid == 0) //子进程 { n = 3; while( n > 0) { n--; printf("child self id is %d, parent = %d\n",getpid(),getppid()); //父进程是fork创建后大于0的那个进程 sleep(1); } exit(3); //这里正常退出 } else //父进程调用waitpid等待子进程退出,这样就会变成同步机制(没有调用wait的时候，是异步机制) { int stat_val; waitpid(pid,&stat_val,0); if(WIFEXITED(stat_val)) //正常退出，打印出状态码 //WIFEXITED 定义格式：wait if exited的缩写 { printf("child exited wist code %d\n",WEXITSTATUS(stat_val)); } else if(WIFSIGNALED(stat_val)) //信号退出，打印出状态码 { printf("signal teminal %d\n",WTERMSIG(stat_val)); } } return 0; //这里返回0，会被exit读到; } 输出结果： child self id is 6638, parent = 6637 child self id is 6638, parent = 6637 child self id is 6638, parent = 6637 child exited wist code 3

7)pipe的学习，父进程写数据，子进程读数据的案例：

#include<stdio.h> #include<stdlib.h> #include<errno.h> #include<unistd.h> #include <fcntl.h> #include <wait.h> int main(int argc, char** argv) { pid_t pid; int fd[2]; if(pipe(fd) < 0) //创建管道 { perror("pipe"); exit(1); } pid = fork(); //创建进程 if(pid < 0) { perror("fork"); exit(1); } //相当于父进程有一个fd[2]数组,子进程还有一个fd[2]数组； if(pid > 0) { close(fd[0]); //关闭读端 write(fd[1],"hello world\n",11); wait(NULL); //父进程等待子进程结束,给子进程收尸 } if(pid == 0) { char buf[120]; close(fd[1]); //关闭写端; sleep(2); //不着急读，让子弹飞一会 int n = read(fd[0],buf,20); // printf("buf is %s",buf); write(1,buf,n); //等价于printf } return 0; } //在终端输入，用“echo $?”命令，查看程序的退出状态；

8)popen和pclose的学习

popen函数的功能，创建一个管道，调用fork产生一个子进程，执行一个shell命令来开启一个进程； 8.1)popen read的使用； #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<ctype.h> int main(int argc, char** argv) { FILE* fp; fp = popen("ls -l","r"); //r或者w，只能选一种 if(!fp) { perror("popen"); exit(1); } int c; while((c = fgetc(fp)) != EOF) //从终端输出的数据，读到文件fp中，并转成大写打印到屏幕上； { putchar(toupper(c)); } pclose(fp); return 0; } 8.2)popen write的使用； #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<ctype.h> int main(int argc, char** argv) { FILE* fp; //前提要有upper这个程序； fp = popen("./upper","w"); //往fp上write，等价于往upper上write; if(!fp) { perror("popen"); exit(1); } int n = 5; while(n > 0) { n--; fprintf(fp,"hello world,%d\r\n",n); } pclose(fp); return 0; }

9）有名管道的读写操作

先用mkfifo命令创建一个管道，如mkfifo aa，利用这个aa进行操作； 9.1) fifo有名管道的的读操作 #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int main(int argc, char** argv) //read { char buf[20]; int fd = open("./aa",O_RDONLY); if(fd < 0) { perror("open"); exit(1); } ssize_t n = read(fd,buf,20); write(1,buf,n); //屏幕上输出 close(fd); return 0; } 9.2) fifo有名管道的的写操作 #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int main(int argc, char** argv) //read { int fd = open("./aa",O_WRONLY); //卡主到这里,打开管道的时候 if(fd < 0) { perror("open"); exit(1); } write(fd,"hello world\n",12); //把文件写到fifo中去； close(fd); return 0; } 上面打开任何一个读操作和写操作，都会阻塞，只有成对出现才可以；

10)共享内存(创建的ipc共享内存，可以用ipcs命令进行查看) ipcs -> ipc show的意思；

ipc相关命令： ipcs -m,只查看共享内存的； ipcrm -m 65538(shmid)，删除一个共享内存 例如：0x63056ad9 32771 jiang 664 20 0 key shmid owner perms bytes nattch status 0x00000000 32768 jiang 600 524288 2 dest 上面两条信息中， perms是权限的意思，nattch->number attch多少个程序共享了； criteria 美 [kraɪ'tɪriə] 原则，标准 //共享内存简单案例分析: #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include<sys/ipc.h> #include<sys/shm.h> //ipc-共享内存有句柄的意思； int main(int argc, char** argv) { key_t key = ftok("./test.txt",99); //key是一个索引值，根据hash算法得到的； printf("key is %#x\n",key); //把用户空间的20个字节，映射到内核空间； int shmId = shmget(key,20,IPC_CREAT | 0664); //向内核申请一块空间，并返回共享内存的id;跟open打开一个文件一样; if(shmId < 0) { perror("shmget"); exit(1); } printf("shmId = %d\n",shmId); //打印共享内存文件描述符，类似文件描述符fd; //创建粘连关系 void* shmp = shmat(shmId,NULL,0); //把创建的共享内存(从内核创建的)，映射到我们的用户空间；shmat -> shared memory attach的意思； if(shmp < 0)//不成功 { perror("shmat"); exit(1); } printf("shmp = %p\n",shmp); //得到内核返回来的空间地址 char* cp = (char*)shmp; //下面两条语句是互斥的,相当于两个程序 // snprintf(cp,20,"123456\n"); //向共享内存(内核开辟的存储空间)写入数据 printf("%s",cp); //读共享内存里面的数据 //取消粘连关系 shmdt(shmp); //取消映射关系 return 0; }

11）多进程利用共享内存进行通信

shmctl这个函数没有用到，用的是ftok,fork,shmget,shmat,shmdt等系统函数； #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include<sys/ipc.h> #include<sys/shm.h> #include<string.h> #include<wait.h> //ipc-共享内存有句柄的意思； int main(int argc, char** argv) { key_t key = ftok("./test.txt",99); //key是一个索引值，根据hash算法得到的； printf("key is %#x\n",key); //虽然你想开辟一个20byte的大小，但系统还是会给你开辟一个4096大小的空间 int shmId = shmget(key,20,IPC_CREAT | 0664); //向内核申请一块空间，并返回共享内存的id;跟open打开一个文件一样; if(shmId < 0) { perror("shmget"); exit(1); } printf("shmId = %d\n",shmId); //打印共享内存文件描述符，类似文件描述符fd; //创建粘连关系 void* shmp = shmat(shmId,NULL,0); //把创建的共享内存(从内核创建的)，映射到我们的用户空间；shmat -> shared memory attach的意思； char* charp = (char*)shmp; if(shmp < 0)//不成功 { perror("shmat"); exit(1); } printf("shmp = %p\n",shmp); //得到内核返回来的空间地址 bzero(charp,100); //保证前100个字符是空的 pid_t pid = fork(); if(pid < 0) { perror("fork"); exit(1); } if(pid > 0) //父进程 { while(1) { scanf("%s",charp); //scanf是阻塞读，把读到的数据存放到共享内存中去了 if(!strcmp(charp,"quit")) { break; } } wait(NULL); //退出后，等待给儿子收尸 } else //子进程 { while(1) { if(!strcmp(charp,"quit")) { break; } if(*charp) //如果是空，就等待；不是空，就打印里面的内容; { printf("child read is %s\n",charp); bzero(charp,100); } sleep(1); //禁止高速运转判断 } } shmdt(shmp); return 0; }

12)消息队列(系统内核维护了一个存放消息的队列)

作为一个程序员，应该对边界问题比较敏感！这是一个合格的程序员的标准； #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include<sys/ipc.h> #include<sys/msg.h> #include<string.h> #include<wait.h> //消息队列，相当于晾衣架那样，一个人把东西一个一个挂上去，另外一个人从另一端拿走； //发消息相当于把衣服挂到队列上，读消息相当于把衣服拿走； //消息队列的操作和共享内存的操作，几乎是一样的； //注意3个系统函数，msgget,msgsnd,msgrcv； #define msglen 20 typedef struct myMsg { long mtype; char mtext[msglen]; }msg_t; int main(int argc, char** argv) { key_t key = ftok("./test.txt",19); //key是一个索引值，根据hash算法得到的； printf("key is %#x\n",key); int mqid = msgget(key,IPC_CREAT | 0666); if(mqid < 0) { perror("ipc queue"); exit(1); } printf("mqid is = %d\n",mqid); msg_t buf; //下面的发送数据和接收数据其实是两个程序，是互斥的，需要编译两次； //发消息队列到内核空间 // buf.mtype = 1; //存储第一个类型数据 // strncpy(buf.mtext,"hello world\n",msglen); // msgsnd(mqid,&buf,msglen,0); // buf.mtype = 2; //存储第二个类型数据 // strncpy(buf.mtext,"online\n",msglen); // msgsnd(mqid,&buf,msglen,0); //写完的数据，可以用"ipcs -q"查询数据，是否正确写到消息队列中去了； //从内核空间读数据到用户空间 //如果一个类型的消息读完，不同类型的消息也是不能瞎读的，根据类型读，即使有消息，不同类型的消息也是不能读走； //如果没有该类型的消息，就会阻塞到这里； msgrcv(mqid,&buf,msglen,1,0); //取走第1个类型信息，取消息也是根据类型type取消息 printf("msg type is: %ld, msg text is: %s",buf.mtype,buf.mtext); msgrcv(mqid,&buf,msglen,2,0); //取走第2个类型信息 printf("msg type is: %ld, msg text is: %s",buf.mtype,buf.mtext); return 0; } //读消息队列的输出结果 key is 0x13056ad9 mqid is = 4 msg type is: 1, msg text is: hello world msg type is: 2, msg text is: online