system创建一个进程，管道创建一个进程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/time.h>
  5. #include <sched.h>
  7. int main(int argc, char **argv) {
  8.   /*
  9.   uid   用户id
  10.   pid   进程标识id
  11.   ppid  父进程标识id
  12.   comm  命令
  13.   tty   终端的名称
  14.   stime 进程的启动时间
  15.   time  进程的cpu时间
  17.   ps  -e 显示所有进程。
  18.       -f 全格式。
  19.       -h 不显示标题。
  20.       -l 长格式。-w 宽输出。
  21.       -a 显示终端上的所有进程，包括其他用户的进程。
  22.       -r 只显示正在运行的进程。
  23.       -x 显示没有控制终端的进程。
  24.   */
  25.   // int system(const char *comstring);
  26.   // system("ps -o uid,pid,ppid,comm,tty,stime,time ");
  28.   char buf[1024];
  29.   FILE *p;
  30.   char *cmd = "ps -f";
  31.   // 使用管道创建一个进程
  32.   // FILE *popen(const char *cmd, const char *type); type支持"r","w" 读写
  33.   //
  34.   if ((p = popen(cmd, "r")) == NULL)
  35.   {
  36.     printf("popen error!");
  37.     exit(1);
  38.   }
  40.   // int pclose(File *stream);
  41.   while(fgets(buf, sizeof(buf), p)) {
  42.     printf("%s", buf);
  43.   }
  45.   pclose(p);
  47.   pid_t pid, ppid, pgid;
  49.   // pid_t getpid(void); 获取pid
  50.   pid = getpid();
  51.   // pid_t getppid(void); 获取ppid
  52.   ppid = getppid();
  53.   // pid_t getpgid(pid_t pid); // 如果pid=0返回当前进程的组标识符，如果是其他值，返回指定pid的组标识符号
  54.   pgid = getpgid(0); // pid_t getpgrp(void); 相当于getpgid(0);
  56.   uid_t uid = getuid();
  58.   // 获取该进程，进程组，以及用户的进程允许优先级
  59.   // int getpriority(int which, int who);
  60.   // 函数有两个入参，which取值为PRIO_PROCESS,PRIO_PGRP,PRIO_USER;
  61.   // 参数 who 根据which的值确定其具体含义，分别对应进程标识符，进程组标识符，或用户标识符
  62.   // 函数运行成功返回当前进程的优先级，其值介于-20～20之间，值越小代表优先级越高。
  63.   // 如果函数执行出错返回-1，错误原因存在变量errno之中
  64.   int priority = getpriority(PRIO_USER, uid); // 我的uid是501，所以我填写501
  66.   printf("pid=%d,ppid=%d,pgid=%d,uid=%d,priority=%d\n", pid, ppid, pgid, uid, priority);
  68.   return 0;
  69. }

wait 的使用

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h> /**包含相关函数头文件*/
  4. #include <sys/time.h>
  5. #include <sched.h>
  7. int main(int argc, char **argv)
  8. {
  9.   // 复制当前进程的内容，产生一个新的进程，调用fork函数的进程是父进程，所产生的进程是子进程
  10.   // pid_t fork(void);
  11.   pid_t pid = fork();
  12.   int sta, i = -1;
  14.   if (pid < 0)
  15.   {
  16.     printf("创建子进程失败！\n");
  17.     exit(1);
  18.   }
  20.   if (pid == 0)
  21.   {
  22.     printf("这是一个子进程 pid=%d\n", getpid());
  23.     // 使用这种方式，子进程是正常结束的
  24.     // exit(100);
  26.     // 使用这个的时候，父进程获取子进程结束状态时，会知道子进程是因为信号终止的
  27.     abort();
  28.   }
  29.   else
  30.   {
  31.     printf("父进程pid=%d\n", getpid());
  32.     // 暂停1s
  33.     // unsigned int sleep(unsigned int seconds);
  34.     sleep(1);
  35.     printf("这是一个父进程\n");
  37.     // pid_t wait(int *status); 函数会暂停当前进程的运行。直到有信号到来或子进程结束
  38.     // 如果调用时子进程已经结束，则函数立刻返回，返回值为子进程pid，子进程结束状态由*status返回。
  39.     if (pid != wait(&sta))
  40.     {
  41.       printf("等待子进程错误。\n");
  42.       exit(1);
  43.     }
  45.     if (WIFSIGNALED(sta)) { // WIFSIGNALED 如果子进程是因为信号而结束的，返回真
  46.       i = WTERMSIG(sta);    // 如果WIFSIGNALED(status)返回值为真，返回引起终止的信号代码
  47.       printf("子进程是由信号结束的\n");
  48.     }
  50.     // WIFEXITED 正常结束返回非0值
  51.     if (WIFEXITED(sta))
  52.     {                       // 判断进程是否为正常结束
  53.       i = WEXITSTATUS(sta); // 返回状态值 WEXITSTATUS(sta)状态为真时，返回状态值低8位
  54.       printf("子进程是正常结束的\n");
  55.     }
  57.     // 输出子进程标识符
  58.     printf("子进程pid=%d\n", pid);
  59.     // 输出子进程结束状态值
  60.     printf("exit status=%d\n", i); // exit status=0
  61.   }
  63.   return 0;
  64. }

waitpid 的使用

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. //waitpid()使用示例
  5. int main(void)
  6. {
  7.   pid_t pid, ret;
  8.   int status = -1;
  9.   printf("main process pid = %d\n", getpid());
  10.   pid = fork(); //创建子进程
  11.   if (pid < 0)
  12.   {
  13.     printf("error fork\n");
  14.     exit(1);
  15.   }
  16.   if (pid == 0) //子进程
  17.   {
  18.     printf("child process pid = %d\n", getpid());
  19.     printf("------------------\n");
  20.     sleep(5);
  21.     exit(0);
  22.   }
  23.   if (pid > 0) //父进程
  24.   {
  25.     // pid_t waitpid(pid_t pid, int *status, int option); // 这里的pid_t pid 为欲要等待的子进程标识符
  26.     // option 的取值范围
  27.     //    WNOHANG   如果没有任何已经结束的子进程，则立即返回
  28.     //    WUNTRACED 如果子程序进入暂停状态，则立即返回
  29.     // waitpid(...)和wait(...)函数的区别，wait阻塞调用进程直到至少有一个子进程结束，waitpid则可以选择不阻塞立即返回
  30.     printf("这是父进程");
  31.     // waitpid(pid, &sta, WNOHANG);   // 这里没有阻断
  32.     // waitpid(pid, &sta, WUNTRACED); // 这里阻断，先执行子进程在执行父进程
  34.     do
  35.     {
  37.       // 调用waitpid，且父进程不阻塞
  38.       ret = waitpid(pid, &status, WNOHANG);
  39.       //若子进程还没有退出，则父进程暂停1s
  40.       //等待时候执行下面语句
  41.       if (ret == 0)
  42.       {
  43.         printf("the child process has no exited\n");
  44.         sleep(1);
  45.       }
  46.       if (WIFSTOPPED(status)) {
  47.         int i = WSTOPSIG(status); // WIFSTOPPED结果为真
  48.         printf("子进程处于暂停状态 status=%d\n", status);
  49.       }
  50.     } while (ret == 0);
  51.     //子进程退出
  52.     if (pid == ret) //ret>0
  53.     {
  54.       printf("child process exited\n");
  55.     } else {
  56.       printf("some error occured.\n");
  57.     }
  58.   }
  60.   /*
  61.   main process pid = 26713
  62.   the child process has no exited
  63.   child process pid = 26714
  64.   ------------------
  65.   子进程处于暂停状态 status=-1
  66.   the child process has no exited
  67.   子进程处于暂停状态 status=-1
  68.   the child process has no exited
  69.   子进程处于暂停状态 status=-1
  70.   the child process has no exited
  71.   子进程处于暂停状态 status=-1
  72.   the child process has no exited
  73.   子进程处于暂停状态 status=-1
  74.   child process exited
  75.   */
  76. }
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h> /**包含相关函数头文件*/
  4. #include <sys/time.h>
  5. #include <sched.h>
  7. int main(int argc, char **argv)
  8. {
  9.   // 复制当前进程的内容，产生一个新的进程，调用fork函数的进程是父进程，所产生的进程是子进程
  10.   // pid_t fork(void);
  11.   pid_t pid = fork();
  12.   int sta, i = -1;
  13.   pid_t temp = 0;
  15.   if (pid < 0)
  16.   {
  17.     printf("创建子进程失败！\n");
  18.     exit(1);
  19.   }
  21.   if (pid == 0)
  22.   {
  23.     printf("这是一个子进程 pid=%d\n", getpid());
  24.     sleep(5); // 这里进程暂停了，但是没有切换父进程执行
  25.     printf("这是一个子进程 pid=%d\n", getpid());
  26.     exit(0);
  27.   } else {
  28.     printf("这是父进程\n");
  29.     temp = waitpid(pid, &sta, WUNTRACED); // 这里堵塞当前进程，必须等待子程序结束
  30.     printf("%d\n", temp);
  31.     if (pid != temp)
  32.     {
  33.       printf("等待子进程错误。\n");
  34.       exit(1);
  35.     }
  37.     // 如果子进程处于暂停执行情况则此宏值为真。一般只有使用 WUNTRACED 时才会有此情况。 
  38.     if (WIFSTOPPED(sta))
  39.     {                      // WIFSTOPPED 如果子程序处于暂停状态，返回值为真
  40.       i = WSTOPSIG(sta);   // WIFSTOPPED结果为真
  41.       printf("子进程处于暂停状态");
  42.     }
  44.     // 输出子进程标识符
  45.     printf("子进程pid=%d\n", pid);
  46.     // 输出子进程结束状态值
  47.     printf("exit status=%d\n", i); // exit status=0
  48.   }
  50.   /*
  51.   这是父进程
  52.   这是一个子进程 pid=27169
  53.   这是一个子进程 pid=27169
  54.   27169
  55.   子进程pid=27169
  56.   exit status=-1
  57.   */
  59.   return 0;
  60. }

写时拷贝

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h> /**包含相关函数头文件*/
  4. #include <sys/time.h>
  5. #include <sched.h>
  6. int i = 1;
  8. void child_process() {
  9.   printf("子进程：%d i=%d \n", getpid(), i); // 输出1
  10.   i++; // 当它改变了i的值时，会有进行写时拷贝，会有自己的i变量，不会影响父进程
  11.   printf("子进程：%d i=%d \n", getpid(), i); // 输出2
  12. }
  14. int main(int argc, char **argv)
  15. {
  16.   pid_t pid;
  17.   int status;
  18.   // 复制进程，但是它会有自己的空间
  19.   pid = fork();
  20.   if (pid < 0) {
  21.     printf("创建进程失败");
  22.     exit(1);
  23.   }
  25.   if (pid == 0) {
  26.     child_process();
  27.   } else {
  28.     sleep(1);
  29.     printf("父进程：%d i=%d \n", getpid(), i); // 输出1
  30.     if (pid != wait(&status)) {
  31.       printf("等待子进程失败");
  32.       exit(1);
  33.     }
  34.   }
  36.   return 0;
  37. }

exec

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h> /**包含相关函数头文件*/
  4. #include <sys/time.h>
  5. #include <sched.h>
  7. int main(int argc, char **argv)
  8. {
  9.   // vfork函数与fork函数的区别，vfork保证子进程先运行，在他exec或exit之后，父进程才可能被调度
  10.   // 如果在调用这两个函数之前，子进程的执行依赖父进程的进一步执行，则会导致死锁。
  11.   // pid_t pid = vfork(); vfork已经被废弃了，要求使用。
  12.   // warning: 'vfork' is deprecated: Use posix_spawn or fork [-Wdeprecated-declarations]
  14.   execlp("ps", "ps", "-o", "pid,ppid,comm", NULL);
  16.   // exec 函数有6种不同形式，统称exec函数族，他们一般形式为：
  17.   // int execl(const char *path, const char *arg, ...);
  18.   // int execlp(const char *file, const char *arg, ...);
  19.   // int execle(const char *path, const char *arg, ..., char *const envp[]);
  21.   // int execv(const char *path, const char *arv[], ...);
  22.   // int execvp(const char *file, const char *arv[], ...);
  23.   // int execve(const char *path, const char *arv[], ..., char *const envp[]);
  25.   // char *argv[] = {"full path", "param1", "param2", ..., NULL};
  26.   // char *envp[] = {"name1=val1", "name2=val2", ..., NULL};
  28.   // envp 指定新环境的环境变量
  30.   return 0;
  31. }

终止进程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h> /**包含相关函数头文件*/
  5. int main(int argc, char **argv)
  6. {
  7.   printf("Linux C\n");
  8.   printf("特别棒");
  9.   // exit(1);
  10.   // void _exit(int status); 他直接使进程停止运行，清除其使用的内存空间
  11.   // exit函数是在_exit函数上进行了一些包装，它还会检查文件打开状态，清理I/O缓冲操作等，例如把文件缓冲系统的内容写回文件。
  12.   _exit(1);
  14.   // abort异常终止进程函数
  16.   return 0;
  17. }

守护进程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h> /**包含相关函数头文件*/
  4. #include <signal.h>
  5. #include <sys/types.h>
  6. #include <sys/stat.h>
  8. int main(int argc, char **argv)
  9. {
  10.   // 创建守护进程
  11.   // 将子进程放入后台运行，就说创建守护进程的第一步，在创建过程中调用fork函数创建一个子进程，并把父进程杀死，
  12.   // 使子进程进入后台执行，进而断开子进程与控制终端的关联
  13.   // 在Linux中，父进程先于子进程退出会使子进程成为孤儿进程，而当系统发现孤儿进程之后，会自动由init进程（PID为1）收养它，
  14.   // 这样原先子进程就会变成init的子进程
  16.   pid_t pid;
  17.   FILE *fp;
  18.   char *buf = "这是一个示例程序\n";
  19.   pid = fork();
  21.   if (pid < 0) {
  22.     printf("创建子进程失败");
  23.     exit(1);
  24.   }
  26.   if (pid > 0) {
  27.     // 结束父进程
  28.     exit(0);
  29.   }
  31.   // pid_t setsid(void); // 创建新会话
  32.   setsid();
  34.   int filesize = 1024;
  35.   int i = 0;
  37.   for (i = 0; i < filesize; i++) {
  38.     // 子进程会继承父进程打开的文件描述符，在这里子进程全部关掉
  39.     close(i);
  40.   }
  41.   // 切换目录
  42.   chdir("/tmp");
  44.   // 重设文件权限掩码
  45.   // 守护进程的文件掩码是从创建它的父进程哪里继承下来的，这会给守护进程使用文件带来诸多麻烦。为此，
  46.   // 有必要将文件的权限掩码设置为0，进而增强守护进程的灵活性。
  47.   umask(0);
  49.   // 处理SIGCHLD信号
  50.   // 对于某些进程，尤其是服务器进程，往往在请求到来时，创建子进程处理请求，而父进程则保持循环，
  51.   // 以接收更多客户连接，在这种情况下，如果父进程等待子进程结束，将增加父进程的负担，
  52.   // 进而会影响服务器的并发性能；如果父进程不等待子进程结束，子进程将会变成僵尸进程（zombie），继续占有系统资源。
  53.   // 在Linux系统中，有几种方式可以绕过这些问题，其中最简单的方法就是，将SIGCHLD信号的操作设置为SIG_IGN
  54.   signal(SIGCHLD, SIG_IGN);
  56.   while(1) {
  57.     fp = fopen("/tmp/test", "a");
  58.     if (fp == NULL) {
  59.       perror("打开文件失败！");
  60.       exit(1);
  61.     }
  63.     fputs(buf, fp);
  64.     fclose(fp);
  65.     sleep(1);
  66.   }
  69.   return 0;
  70. }

守护进程，打印日志

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h> /**包含相关函数头文件*/
  4. #include <signal.h>
  5. #include <sys/types.h>
  6. #include <sys/stat.h>
  7. #include <time.h>
  8. #include <syslog.h>
  10. int main(int argc, char **argv)
  11. {
  12.   // 创建守护进程
  13.   // 将子进程放入后台运行，就说创建守护进程的第一步，在创建过程中调用fork函数创建一个子进程，并把父进程杀死，
  14.   // 使子进程进入后台执行，进而断开子进程与控制终端的关联
  15.   // 在Linux中，父进程先于子进程退出会使子进程成为孤儿进程，而当系统发现孤儿进程之后，会自动由init进程（PID为1）收养它，
  16.   // 这样原先子进程就会变成init的子进程
  18.   pid_t pid;
  19.   FILE *fp;
  20.   char *buf = "这是一个示例程序\n";
  21.   pid = fork();
  23.   if (pid < 0) {
  24.     printf("创建子进程失败");
  25.     exit(1);
  26.   }
  28.   if (pid > 0) {
  29.     // 结束父进程
  30.     exit(0);
  31.   }
  33.   // pid_t setsid(void); // 创建新会话
  34.   setsid();
  36.   int filesize = 1024;
  37.   int i = 0;
  39.   for (i = 0; i < filesize; i++) {
  40.     // 子进程会继承父进程打开的文件描述符，在这里子进程全部关掉
  41.     close(i);
  42.   }
  43.   // 切换目录
  44.   chdir("/");
  46.   // 重设文件权限掩码
  47.   // 守护进程的文件掩码是从创建它的父进程哪里继承下来的，这会给守护进程使用文件带来诸多麻烦。为此，
  48.   // 有必要将文件的权限掩码设置为0，进而增强守护进程的灵活性。
  49.   umask(0);
  51.   // 处理SIGCHLD信号
  52.   // 对于某些进程，尤其是服务器进程，往往在请求到来时，创建子进程处理请求，而父进程则保持循环，
  53.   // 以接收更多客户连接，在这种情况下，如果父进程等待子进程结束，将增加父进程的负担，
  54.   // 进而会影响服务器的并发性能；如果父进程不等待子进程结束，子进程将会变成僵尸进程（zombie），继续占有系统资源。
  55.   // 在Linux系统中，有几种方式可以绕过这些问题，其中最简单的方法就是，将SIGCHLD信号的操作设置为SIG_IGN
  56.   signal(SIGCHLD, SIG_IGN);
  58.   time_t now;
  59.   while(1) {
  60.     time(&now);
  61.     // void syslog(int priority, char *format, ...)
  62.     // 写入到/var/log/syslog文件中
  63.     syslog(LOG_USER|LOG_INFO, "Current time:\t%s\t\t\n", ctime(&now));
  64.     sleep(1);
  65.   }
  68.   return 0;
  69. }

进程通信

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <fcntl.h>
  5. #include <sys/wait.h>
  6. #define BUFSIZE 256
  8. int main(int argc, char **argv)
  9. {
  10.   // 父进程向子进程，单向传递数据
  11.   pid_t cpid;
  12.   int fifod[2];
  13.   int sta;
  14.   char buf[BUFSIZE] = "Linux C is very good!";
  16.   // 创建匿名管道
  17.   // int pipe(int fd[2]);
  19.   if (pipe(fifod) < 0) {
  20.     printf("pipe error.\n");
  21.     exit(1);
  22.   }
  24.   cpid = fork();
  25.   if (cpid < 0) {
  26.     printf("fork error.\n");
  27.     exit(1);
  28.   }
  30.   if (cpid == 0) {
  31.     close(fifod[0]); // 写入时，要关闭读端
  32.     write(fifod[1], buf, sizeof(buf));
  33.   } else {
  34.     close(fifod[1]);
  35.     read(fifod[0], buf, sizeof(buf)); // 读取时，要关闭写端
  36.     printf("buf=%s\n", buf);
  37.     if (cpid != wait(&sta)) {
  38.       printf("wait error.\n");
  39.       exit(1);
  40.     }
  41.   }
  43.   return 0;
  44. }