9、进程

此文编写参考朱有鹏老师视频课程，错误之处，欢迎指正。

一、程序的开始和结束

1、main函数由谁调用

(1)编译链接时的引导代码。操作系统下的应用程序其实在main执行前也需要先执行一段引导代码才能去执行main，我们写应用程序时不用考虑引导代码的问题，编译连接时（准确说是连接时）由链接器将编译器中事先准备好的引导代码给连接进去和我们的应用程序一起构成最终的可执行程序。（没有引导代码是不行的）
(2)运行时的加载器。加载器是操作系统中的程序，当我们去执行一个程序时（譬如./a.out，譬如代码中用exec族函数来运行）加载器负责将这个程序加载到内存中去执行这个程序。
(3)程序在编译连接时用链接器，运行时用加载器，这两个东西对程序运行原理非常重要。
(4)argc和argv的传参如何实现

2、程序如何结束

（1）正常终止：return、exit、_exit
（2）非正常终止：自己或他人发信号终止进程
（3）、atexit注册进程终止处理函数

• atexit注册多个进程终止处理函数，先注册的后执行（先进后出，和栈一样）
• return、exit和_exit的区别：return和exit效果一样，都是会执行进程终止处理函数，但是用_exit终止进程时并不执行atexit注册的进程终止处理函数。此外，exit结束进程的时候会刷新缓冲区，但是_exit不会。
• 例程

#include<stdio.h>
 #include <stdlib.h>

void func1(void)
{
  printf("func1\n");
}
void func2(void)
{
  printf("func2\n");
}
int main()
{
  printf("hello world\n");
  
  atexit(func1);
  atexit(func2);

  return 0;
}

二、进程环境

1、环境变量

(1)export命令查看环境变量
(2)进程环境表介绍.每一个进程中都有一份所有环境变量构成的一个表格，也就是说我们当前进程中可以直接使用这些环境变量。进程环境表其实是一个字符串数组，用environ变量指向它。
(3)程序中通过environ全局变量使用环境变量
(4)我们写的程序中可以无条件直接使用系统中的环境变量，所以一旦程序中用到了环境变量那么程序就和操作系统环境有关了。
(5)获取指定环境变量函数getenv

2、例程：environ使用方法

#include<stdio.h>
#include<unistd.h>
int main()
{
  extern char** environ;//事实上这是一个二级的指针，则environ[i]就是一个指针数组。
  int i=0;
  while(1)
  {
    if(environ[i]!=NULL)
    {
      printf("environ[%d]=%s\n",i,environ[i]);//这里是输出字符串，因为当我们用一个指针指向一个字符串的时候，那么这时候用printf输出字符串的时候和输出指向这个字符串的指针的效果是一样的。
      i++;
    }
    else
    {
      break;
    }
  }
  return 0;
}

3、进程运行的虚拟地址空间

(1)操作系统中每个进程在独立地址空间中运行
(2)每个进程的逻辑地址空间均为4GB（32位系统）
(3)0-1G为OS，1-4G为应用
(4)虚拟地址到物理地址空间的映射
(5)意义。进程隔离，提供多进程同时运行

三、进程的正式引入

1、什么是进程

（1）程序：存储在磁盘上的指令和数据的有序集合。如下就是一个程序，此刻它正安静地躺在硬盘上。

01 #include <stdio.h>
02
03 int main(int argc, char *argv[])
04{
05	printf("hello world!\n");
06	return 0;
07}

（2）进程

进程：具有一定独立功能的程序在一个数据集合上的一次动态执行过程。它是动态的，包括创建、调度、执行和消亡（由操作系统完成的）,如一个静态的可执行程序a.out的一次运行过程（./a.out去运行到结束）就是一个进程。

（3）进程控制块PCB（process control block）:内核中专门用来管理一个进程的数据结构。

（4）进程和程序的区别

1.程序是产生进程的基础。
2.程序的每次执行构成不同的进程。
3.进程是程序功能的体现（还记得之前提到的程序员日常工作中的一个重要事项----调试程序吗？调试的过程实际上就是程序的执行，就是本次程序功能的体现，因此这个时候它就是一个进程）。
4.通过多次执行，一个程序可对应多个进程；通过调用关系，一个进程可包含多个程序。

	程序	进程
状态	静态的，是有序代码的集合	动态的，是程序功能的执行过程
生命期	永久的，长久保存在存储设备上	暂时的，一个程序执行结束，则它对应的进程结束

我们以一个生活中的例子来加深对进程和程序的理解：
1.有一位计算机科学家，他的女儿要过生日了，他准备给女儿做一个生日蛋糕，于是他去找了一本菜谱，跟着菜谱学习做蛋糕。
菜谱=程序 科学家=CPU 做蛋糕的原材料=数据 做蛋糕的过程=进程
2.科学家正在做蛋糕的时候，突然他的小儿子跑过来，说他的手被扎破了，于是科学家又去找了一本医疗手册，给小儿子处理伤口，处理完伤口之后，继续做生日蛋糕
医疗手册=新程序 给小儿子处理伤口=新进程
从做蛋糕切换到优先包扎伤口=进程切换 处理完伤口继续做生日蛋糕=进程恢复

(5)进程ID

(1)getpid、getppid、getuid、geteuid、getgid、getegid
(2)实际用户ID和有效用户ID区别（可百度）

(6)多进程调度原理

(1)操作系统同时运行多个进程
(2)宏观上的并行和微观上的串行
(3)实际上现代操作系统最小的调度单元是线程而不是进程

2、进程的创建

(1)使用fork函数来创建一个进程

头文件: #include <unistd.h>
函数原型: pid_t fork(void);
返回值: 成功时，父进程返回子进程的进程号(>0的非零整数)，子进程中返回0;通过fork函数的返回值区分父子进程。
父进程: 执行fork函数的进程。
子进程: 父进程调用fork函数之后，生成的新进程。

请重点注意：这个函数的返回值和我们接触的绝大部分函数的返回值不一样。
一般地，一个函数的返回值只有一个值，但是该函数的返回值却有两个。实际上关于这个函数的返回值究竟有几个，可以换一种方式来理解，因为这个函数执行之后，系统中会存在两个进程----父进程和子进程，在每个进程中都返回了一个值，所以给用户的感觉就是返回了两个值。

(2)进程的特点：

1.在linux中，一个进程必须是另外一个进程的子进程，或者说一个进程必须有父进程，但是可以没有子进程。
2.子进程继承了父进程的内容，包括父进程的代码，变量，pcb，甚至包括当前PC值。在父进程中，PC值指向当前fork函数的下一条指令地址，因此子进程也是从fork函数的下一条指令开始执行。父子进程的执行顺序是不确定的，可能子进程先执行，也可能父进程先执行，取决于当前系统的调度。
3.父子进程有独立的地址空间、独立的代码空间，互不影响，就算父子进程有同名的全局变量，但是由于它们处在不同的地址空间，因此不能共享。
4.子进程结束之后，必须由它的父进程回收它的一切资源，否则就会成为僵尸进程。
5.如果父进程先结束，子进程会成为孤儿进程，它会被INIT进程收养，INIT进程是内核启动之后，首先被创建的进程。

(3)例程

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
	pid_t p1 = -1;
	
	p1 = fork();		// 看上去像是返回2次
	
	if (p1 == 0)
	{
		// 这里一定是子进程
		
		// 先sleep一下让父进程先运行，先死
		sleep(1);
		
		printf("子进程, pid = %d.\n", getpid());		
		printf("hello world.\n");
		printf("父进程ID = %d.\n", getppid());
	}
	
	if (p1 > 0)
	{
		// 这里一定是父进程
		printf("父进程, pid = %d.\n", getpid());
		printf("父进程, p1 = %d.\n", p1);
	}
	
	if (p1 < 0)
	{
		// 这里一定是fork出错了
	}
	
	// 在这里所做的操作
	//printf("hello world, pid = %d.\n", getpid());

	return 0;
}

3、父子进程对文件的操作

（1）、子进程继承父进程中打开的文件

(1)上下文：父进程先open打开一个文件得到fd，然后在fork创建子进程。之后在父子进程中各自write向fd中写入内容
(2)测试结论是：接续写。实际上本质原因是父子进程之间的fd对应的文件指针是彼此关联的（很像O_APPEND标志后的样子）
(3)实际测试时有时候会看到只有一个，有点像分别写。但是实际不是，原因是

（2）、父子进程各自独立打开同一文件实现共享

(1)父进程open打开1.txt然后写入，子进程打开1.txt然后写入，结论是：分别写。原因是父子进程分离后才各自打开的1.txt，这时候这两个进程的PCB已经独立了，文件表也独立了，因此2次读写是完全独立的。
(2)open时使用O_APPEND标志看看会如何？实际测试结果标明O_APPEND标志可以把父子进程各自独立打开的fd的文件指针给关联起来，实现分别写。

（3）、总结

(1)父子进程间终究多了一些牵绊
(2)父进程在没有fork之前自己做的事情对子进程有很大影响，但是父进程fork之后在自己的if里做的事情就对子进程没有影响了。本质原因就是因为fork内部实际上已经复制父进程的PCB生成了一个新的子进程，并且fork返回时子进程已经完全和父进程脱离并且独立被OS调度执行。
(2)子进程最终目的是要独立去运行另外的程序

（4）、例程

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

int main(void)
{
	// 首先打开一个文件
	int fd = -1;
	pid_t pid = -1;
	
	// fork创建子进程
	pid = fork();
	if (pid > 0)
	{
		// 父进程中
		fd = open("1.txt", O_RDWR | O_APPEND);
		if (fd < 0)
		{
			perror("open");
			return -1;
		}
		
		printf("parent.\n");
		write(fd, "hello", 5);
		sleep(1);
	}
	else if (pid == 0)
	{
		// 子进程
		fd = open("1.txt", O_RDWR | O_APPEND);
		if (fd < 0)
		{
			perror("open");
			return -1;
		}
		
		printf("child.\n");
		write(fd, "world", 5);
		sleep(1);
	}
	else
	{
		perror("fork");
		exit(-1);
	}
	close(fd);
	
	
#if 0
	// 首先打开一个文件
	int fd = -1;
	pid_t pid = -1;
	
	fd = open("1.txt", O_RDWR | O_TRUNC);
	if (fd < 0)
	{
		perror("open");
		return -1;
	}
	
	// fork创建子进程
	pid = fork();
	if (pid > 0)
	{
		// 父进程中
		printf("parent.\n");
		write(fd, "hello", 5);
		sleep(1);
	}
	else if (pid == 0)
	{
		// 子进程
		printf("child.\n");
		write(fd, "world", 5);
		sleep(1);
	}
	else
	{
		perror("fork");
		exit(-1);
	}
	close(fd);	
#endif
return 0;
}

4、进程的诞生和消亡

1、进程的诞生

(1)进程0和进程1
(2)fork
(3)vfork

2、进程的消亡

(1)正常终止和异常终止
(2)进程在运行时需要消耗系统资源（内存、IO），进程终止时理应完全释放这些资源（如果进程消亡后仍然没有释放相应资源则这些资源就丢失了）
(3)linux系统设计时规定：每一个进程退出时，操作系统会自动回收这个进程涉及到的所有的资源（譬如malloc申请的内容没有free时，当前进程结束时这个内存会被释放，譬如open打开的文件没有close的在程序终止时也会被关闭）。但是操作系统只是回收了这个进程工作时消耗的内存和IO，而并没有回收这个进程本身占用的内存（8KB，主要是task_struct和栈内存）
(4)因为进程本身的8KB内存操作系统不能回收需要别人来辅助回收，因此我们每个进程都需要一个帮助它收尸的人，这个人就是这个进程的父进程。

3、僵尸进程

(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”，在这一段（子进程已经结束且父进程尚未帮其收尸）子进程就被成为僵尸进程。
(2)子进程除task_struct和栈外其余内存空间皆已清理
(3)父进程可以使用wait或waitpid以显式回收子进程的剩余待回收内存资源并且获取子进程退出状态。
(4)父进程也可以不使用wait或者waitpid回收子进程，此时父进程结束时一样会回收子进程的剩余待回收内存资源。（这样设计是为了防止父进程忘记显式调用wait/waitpid来回收子进程从而造成内存泄漏）

4、孤儿进程

(1)父进程先于子进程结束，子进程成为一个孤儿进程。
(2)linux系统规定：所有的孤儿进程都自动成为一个特殊进程（进程1，也就是init进程）的子进程。

5、父进程回收子进程

1、wait的工作原理

(1)子进程结束时，系统向其父进程发送SIGCHILD信号
(2)父进程调用wait函数后阻塞
(3)父进程被SIGCHILD信号唤醒然后去回收僵尸子进程
(4)父子进程之间是异步的，SIGCHILD信号机制就是为了解决父子进程之间的异步通信问题，让父进程可以及时的去回收僵尸子进程。
(5)若父进程没有任何子进程则wait返回错误

2、wait实战编程
例程：

#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
  pid_t pid=-1;
  pid_t ret=-1;
  int status=-1;
  pid=fork();
  if(pid>0)
  {
    printf("this is parent process,and the pid=%d\n", getppid());
    ret=wait(&status);
    printf("status=%d\n",ret); //该返回值为子进程的PID
    printf("WEXITSTATUS(status)=%d\n",WEXITSTATUS(status));//正常终止的终止值是多少
    printf("WIFEXITED(status)=%d\n", WIFEXITED(status));//子进程是否正常退出
    printf("WIFSIGNALED(status)=%d\n", WIFSIGNALED(status));//子进程是否非正常退出
     
  }
  else if(pid==0)
  {
    printf("this is child process,and the pid=%d\n", getpid());
    return 55;
  }
  else
  {
    perror("fork:");
    exit(-1);
  }
  return 0;
}

(1)wait的参数status。status用来返回子进程结束时的状态，父进程通过wait得到status后就可以知道子进程的一些结束状态信息。
(2)wait的返回值pid_t，这个返回值就是本次wait回收的子进程的PID。当前进程有可能有多个子进程，wait函数阻塞直到其中一个子进程结束wait就会返回，wait的返回值就可以用来判断到底是哪一个子进程本次被回收了。
对wait做个总结：wait主要是用来回收子进程资源，回收同时还可以得知被回收子进程的pid和退出状态。
(3)fork后wait回收实例
(4)WIFEXITED、WIFSIGNALED、WEXITSTATUS这几个宏用来获取子进程的退出状态。
WIFEXITED宏用来判断子进程是否正常终止（return、exit、_exit退出）
WIFSIGNALED宏用来判断子进程是否非正常终止（被信号所终止）
WEXITSTATUS宏用来得到正常终止情况下的进程返回值的。

3、waitpid
（1）waitpid和wait差别

(1)基本功能一样，都是用来回收子进程
(2)waitpid可以回收指定PID的子进程
(3)waitpid可以阻塞式或非阻塞式两种工作模式

（2）、waitpid原型介绍

(1)参数
(2)返回值

（3）、例程

#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
  pid_t pid=-1;
  pid_t ret=-1;
  int status=-1;
  pid=fork();
  if(pid>0)
  {
    sleep(1);
    printf("this is parent process,and the pid=%d\n", getppid());
    //ret=wait(&status);
    //ret=waitpid(pid+4, &status,0);
    //ret=waitpid(-1, &status, 0);
    ret=waitpid(pid, &status, WNOHANG);
    printf("status=%d\n",ret); 
    
    printf("WEXITSTATUS(status)=%d\n",WEXITSTATUS(status));
    printf("WIFEXITED(status)=%d\n", WIFEXITED(status));
    printf("WIFSIGNALED(status)=%d\n", WIFSIGNALED(status));
     
  }
  else if(pid==0)
  {
   // sleep(1);
    printf("this is child process,and the pid=%d\n", getpid());
    return 55;
  }
  else
  {
    perror("fork:");
    exit(-1);
  }
  return 0;
}

分析：

(1)使用waitpid实现wait的效果
ret = waitpid(-1, &status, 0); -1表示不等待某个特定PID的子进程而是回收任意一个子进程，0表示用默认的方式（阻塞式）来进行等待，返回值ret是本次回收的子进程的PID
(2)ret = waitpid(pid, &status, 0); 等待回收PID为pid的这个子进程，如果当前进程并没有一个ID号为pid的子进程，则返回值为-1；如果成功回收了pid这个子进程则返回值为回收的进程的PID
(3)ret = waitpid(pid, &status, WNOHANG);这种表示父进程要非阻塞式的回收子进程。此时如果父进程执行waitpid时子进程已经先结束等待回收则waitpid直接回收成功，返回值是回收的子进程的PID；如果父进程waitpid时子进程尚未结束则父进程立刻返回（非阻塞），但是返回值为0（表示回收不成功）。

（4）、竟态初步引入

(1)竟态全称是：竞争状态，多进程环境下，多个进程同时抢占系统资源（内存、CPU、文件IO）
(2)竞争状态对OS来说是很危险的，此时OS如果没处理好就会造成结果不确定。
(3)写程序当然不希望程序运行的结果不确定，所以我们写程序时要尽量消灭竞争状态。操作系统给我们提供了一系列的消灭竟态的机制，我们需要做的是在合适的地方使用合适的方法来消灭竟态。

6、exec族函数

1、为什么需要exec函数

(1)fork子进程是为了执行新程序(fork创建了子进程后，子进程和父进程同时被OS调度执行，因此子进程可以单独的执行一个程序，这个程序宏观上将会和父进程程序同时进行)
(2)可以直接在子进程的if中写入新程序的代码。这样可以，但是不够灵活，因为我们只能把子进程程序的源代码贴过来执行（必须知道源代码，而且源代码太长了也不好控制），譬如说我们希望子进程来执行ls -la 命令就不行了（没有源代码，只有编译好的可执行程序）
(3)使用exec族运行新的可执行程序（exec族函数可以直接把一个编译好的可执行程序直接加载运行）
(4)我们有了exec族函数后，我们典型的父子进程程序是这样的：子进程需要运行的程序被单独编写、单独编译连接成一个可执行程序（叫hello），（项目是一个多进程项目）主程序为父进程，fork创建了子进程后在子进程中exec来执行hello，达到父子进程分别做不同程序同时（宏观上）运行的效果。

2、exec族的6个函数介绍

(1)execl和execv 这两个函数是最基本的exec，都可以用来执行一个程序，区别是传参的格式不同。execl是把参数列表（本质上是多个字符串，必须以NULL结尾）依次排列而成（l其实就是list的缩写），execv是把参数列表事先放入一个字符串数组中，再把这个字符串数组传给execv函数。
(2)execlp和execvp 这两个函数在上面2个基础上加了p，较上面2个来说，区别是：上面2个执行程序时必须指定可执行程序的全路径（如果exec没有找到path这个文件则直接报错），而加了p的传递的可以是file（也可以是path，只不过兼容了file。加了p的这两个函数会首先去找file，如果找到则执行执行，如果没找到则会去环境变量PATH所指定的目录下去找，如果找到则执行如果没找到则报错）
(3)execle和execvpe 这两个函数较基本exec来说加了e，函数的参数列表中也多了一个字符串数组envp形参，e就是environment环境变量的意思，和基本版本的exec的区别就是：执行可执行程序时会多传一个环境变量的字符串数组给待执行的程序。

3、execle和execvpe

(1)main函数的原型其实不止是int main(int argc, char **argv)，而可以是
int main(int argc, char **argv, char **env) 第三个参数是一个字符串数组，内容是环境变量。
(2)如果用户在执行这个程序时没有传递第三个参数，则程序会自动从父进程继承一份环境变量（默认的，最早来源于OS中的环境变量）；如果我们exec的时候使用execlp或者execvpe去给传一个envp数组，则程序中的实际环境变量是我们传递的这一份（取代了默认的从父进程继承来的那一份）

4、实例
//test.c

#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
  pid_t pid=-1;
  pid_t ret=-1;
  int status=0;
  pid=fork();
  if(pid>0)
  {
    ret=wait(&status);
    printf("ret=%d\n",ret);
    printf("this is parent process,and the pid =%d\n",getppid());  
  }
  else if(pid==0)
  {
    char *const argv[]={"aaa","bbb","ccc",NULL};
    char * const envp[] = {"AA=aaaa", "XX=abcd", NULL};
    printf("this is child process,and the pid=%d\n",getpid());

    //execl("hello","aaa","bbb","ccc",NULL);
	  //execv("hello", argv);
	 //execl("ls","ls","-l","-a",NULL);
	//execvpe("hello", argv, envp);
	execle("hello", "hello", "-l", "-a", NULL, envp);
  }
  else 
  {
    perror("fork:");
    exit(-1);

  }
  return 0;

}

//hello.c

// env就是我们给main函数额外传递的环境变量字符串数组
int main(int argc, char **argv, char **env)
{
	int i = 0;	
	printf("argc = %d.\n", argc);	
	while (NULL != argv[i])
	{
		printf("argv[%d] = %s\n", i, argv[i]);
		i++;
	}
	i = 0;
	while (NULL != env[i])
	{
		printf("env[%d] = %s\n", i, env[i]);
		i++;
	}	
	return 0;
}

四、进程状态和system函数

1、进程的5种状态

(1)就绪态。这个进程当前所有运行条件就绪，只要得到了CPU时间就能直接运行。
(2)运行态。就绪态时得到了CPU就进入运行态开始运行。
(3)僵尸态。进程已经结束但是父进程还没来得及回收
(4)等待态（浅度睡眠&深度睡眠），进程在等待某种条件，条件成熟后可进入就绪态。等待态下就算你给他CPU调度进程也无法执行。浅度睡眠等待时进程可以被（信号）唤醒，而深度睡眠等待时不能被唤醒只能等待的条件到了才能结束睡眠状态。
(5)暂停态。暂停并不是进程的终止，只是被被人（信号）暂停了，还可以回复的。

2、进程各种状态之间的转换图

3、system函数简介

(1)system函数 = fork+exec
(1)原子操作。原子操作意思就是整个操作一旦开始就会不被打断的执行完。原子操作的好处就是不会被人打断（不会引来竞争状态），坏处是自己单独连续占用CPU时间太长影响系统整体实时性，因此应该尽量避免不必要的原子操作，就算不得不原子操作也应该尽量原子操作的时间缩短。
(2)使用system调用ls

#include<stdio.h>
#include <stdlib.h>

int main()
{ 
 	system("ls -lah");
	return 0;
}

五、守护进程

1、守护进程的引入

1、进程查看命令ps

(1)ps -ajx 偏向显示各种有关的ID号
(2)ps -aux 偏向显示进程各种占用资源

2、向进程发送信号指令kill，用于终止进程

(1)kill -信号编号 进程ID，向一个进程发送一个信号
(2)kill -9 xxx，将向xxx这个进程发送9号信号，也就是要结束进程

3、何谓守护进程

(1)daemon，表示守护进程，简称为d（进程名后面带d的基本就是守护进程）
(2)长期运行（一般是开机运行直到关机时关闭）
(3)与控制台脱离（普通进程都和运行该进程的控制台相绑定，表现为如果终端被强制关闭了则这个终端中运行的所有进程都被会关闭，背后的问题还在于会话）
(4)服务器（Server），服务器程序就是一个一直在运行的程序，可以给我们提供某种服务（譬如nfs服务器给我们提供nfs通信方式），当我们程序需要这种服务时我们可以调用服务器程序（和服务器程序通信以得到服务器程序的帮助）来进行这种服务操作。服务器程序一般都实现为守护进程。

2、常见守护进程

(1)syslogd，系统日志守护进程，提供syslog功能。
(2)cron，cron进程用来实现操作系统的时间管理，linux中实现定时执行程序的功能就要用到cron。

3、编写简单守护进程

1、任何一个进程都可以将自己实现成守护进程
create_daemon函数要素

(1)子进程等待父进程退出
(2)子进程使用setsid创建新的会话期，脱离控制台
(3)调用chdir将当前工作目录设置为/
(4)umask设置为0以取消任何文件权限屏蔽
(5)关闭所有文件描述符
(6)将0、1、2定位到/dev/null

2、调用daemon(0, 0);也可以实现上述功能

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
void create_daemon(void);
int main(void)
{
	create_daemon();
	while (1)
	{
		printf("I am running.\n");	
		sleep(1);
	}
	return 0;
}

// 函数作用就是把调用该函数的进程变成一个守护进程
void create_daemon(void)
{
	//daemon(0, 0);
	pid_t pid = 0;
	pid = fork();
	if (pid < 0)
	{
		perror("fork");
		exit(-1);
	}
	if (pid > 0)
	{
		exit(0);		// 父进程直接退出
	}
	
	// 执行到这里就是子进程
	
	// setsid将当前进程设置为一个新的会话期session，目的就是让当前进程
	// 脱离控制台。
	pid = setsid();
	if (pid < 0)
	{
		perror("setsid");
		exit(-1);
	}
	// 将当前进程工作目录设置为根目录
	chdir("/");
	// umask设置为0确保将来进程有最大的文件操作权限
	umask(0);
	// 关闭所有文件描述符
	// 先要获取当前系统中所允许打开的最大文件描述符数目
	int cnt = sysconf(_SC_OPEN_MAX);
	int i = 0;
	for (i=0; i<cnt; i++)
	{
		close(i);
	}
	open("/dev/null", O_RDWR);
	open("/dev/null", O_RDWR);
	open("/dev/null", O_RDWR)
}

4、使用syslog来记录调试信息和syslog的工作原理

为什么呢？因为守护进程和控制台脱离了，所以就不能输入调试信息到控制台上了，因此需要向日志文件系统中写入一些调试信息，方便记录和调试。
openlog、syslog、closelog

(1)一般log信息都在操作系统的/var/log/messages这个文件中存储着，但是ubuntu中是在/var/log/syslog文件中的。

(2)操作系统中有一个守护进程syslogd（开机运行，关机时才结束），这个守护进程syslogd负责进行日志文件的写入和维护。

(3)syslogd是独立于我们任意一个进程而运行的。我们当前进程和syslogd进程本来是没有任何关系的，但是我们当前进程可以通过调用openlog打开一个和syslogd相连接的通道，然后通过syslog向syslogd发消息，然后由syslogd来将其写入到日志文件系统中。

(4)syslogd其实就是一个日志文件系统的服务器进程，提供日志服务。任何需要写日志的进程都可以通过openlog/syslog/closelog这三个函数来利用syslogd提供的日志服务。这就是操作系统的服务式的设计。

#include<stdio.h>
#include <syslog.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
	printf("my pid is %d\n",getpid());
  openlog("a.out", LOG_CONS|LOG_PID,  LOG_USER);
  syslog(LOG_INFO, "this is my log info.%d\n", 23);
	closelog();
	return 0;
}

然后执行./a.out
然后再cat /var/log/syslog

5、让程序不能被多次运行

1、问题

(1)因为守护进程是长时间运行而不退出，因此./a.out执行一次就有一个进程，执行多次就有多个进程。
(2)这样并不是我们想要的。我们守护进程一般都是服务器，服务器程序只要运行一个就够了，多次同时运行并没有意义甚至会带来错误。
(3)因此我们希望我们的程序具有一个单例运行的功能。意思就是说当我们./a.out去运行程序时，如果当前还没有这个程序的进程运行则运行之，如果之前已经有一个这个程序的进程在运行则本次运行直接退出（提示程序已经在运行）。

2、实现方法：

(1)最常用的一种方法就是：用一个文件的存在与否来做标志。具体做法是程序在执行之初去判断一个特定的文件是否存在，若存在则标明进程已经在运行，若不存在则标明进程没有在运行。然后运行程序时去创建这个文件。当程序结束的时候去删除这个文件即可。
(2)这个特定文件要古怪一点，确保不会凑巧真的在电脑中存在的。

3、例程

#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#define PATHNAME "file.txt"
void delete_file(void);
int main()
{
  int fd=-1;
  fd=open(PATHNAME,  O_RDWR | O_TRUNC | O_CREAT | O_EXCL,0664);
	if(fd<0)
	{
		if(errno==EEXIST)
		{
			printf("进程已经存在，并不需要重复执行\n");
      		exit(-1);
		}
	}
	int i=0;
	atexit(delete_file);// 注册进程清理函数
	for(i=0;i<10;i++)
	{
		printf("I am running!\n");
		sleep(1);
	}
	return 0;
}
void delete_file(void)
{
 remove(PATHNAME);
}

六、进程间通信

1、linux的进程间通信概述

1、为什么需要进程间通信

(1)进程间通信（IPC）指的是2个任意进程之间的通信。
(2)同一个进程在一个地址空间中，所以同一个进程的不同模块（不同函数、不同文件）之间都是很简单的（很多时候都是全局变量、也可以通过函数形参实参传递）
(3)2个不同的进程处于不同的地址空间，因此要互相通信很难。

2、什么样的程序设计需要进程间通信

(1)99%的程序是不需要考虑进程间通信的。因为大部分程序都是单进程的（可以多线程）
(2)复杂、大型的程序，因为设计的需要就必须被设计成多进程程序（我们整个程序就设计成多个进程同时工作来完成的模式），常见的如GUI、服务器。
(3)结论：IPC技术在一般中小型程序中用不到，在大型程序中才会用到。

3、linux内核提供多种进程间通信机制

(1)无名管道和有名管道
(2)SystemV IPC：信号量、消息队列、共享内存
(3)Socket域套接字
(4)信号

4、为什么不详细讲IPC

(1)日常使用少，只有大型程序才能用上
(2)更为复杂，属于linux应用编程中难度最大的部分
(3)细节多
(4)面试较少涉及，对找工作帮助不大
(5)建议后续深入学习时再来实际写代码详细探讨

5、linux的IPC机制1-管道
管道（无名管道）

(1)管道通信的原理：内核维护的一块内存，有读端和写端（管道是单向通信的）
(2)管道通信的方法：父进程创建管理后fork子进程，子进程继承父进程的管道fd
(3)管道通信的限制：只能在父子进程间通信、半双工
(4)管道通信的函数：pipe、write、read、close

有名管道（fifo）

(1)有名管道的原理：实质也是内核维护的一块内存，表现形式为一个有名字的文件
(2)有名管道的使用方法：固定一个文件名，2个进程分别使用mkfifo创建fifo文件，然后分别open打开获取到fd，然后一个读一个写
(3)管道通信限制：半双工（注意不限父子进程，任意2个进程都可）
(4)管道通信的函数：mkfifo、open、write、read、close

6、SystemV IPC介绍

SystemV IPC的基本特点
(1)系统通过一些专用API来提供SystemV IPC功能
(2)分为：信号量、消息队列、共享内存
(3)其实质也是内核提供的公共内存

消息队列

(1)本质上是一个队列，队列可以理解为（内核维护的一个）FIFO
(2)工作时A和B2个进程进行通信，A向队列中放入消息，B从队列中读出消息。

信号量

(1)实质就是个计数器（其实就是一个可以用来计数的变量，可以理解为int a）
(2)通过计数值来提供互斥和同步

共享内存

(1)大片内存直接映射
(2)类似于LCD显示时的显存用法

剩余的2类IPC

(1)信号
(2)Unix域套接字 socket