Linux进程全解(一)

1.程序的开始和结束

•   main函数由谁调用

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

• 程序如何结束

(1)正常终止：return、exit、_exit
(2)非正常终止：自己或他人发信号终止进程

2.atexit注册进程终止处理函数

(2)atexit注册多个进程终止处理函数，先注册的后执行（先进后出，和栈一样）
(2)return、exit和_exit的区别：return和exit效果一样，都是会执行进程终止处理函数，但是用_exit终止进程时并不执行atexit注册的进程终止处理函数。
 

代码演示：

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


//int atexit(void (*function)(void));
void fun1(void)
{

  printf("fun1\n");

}

void fun2(void)
{

  printf("fun2\n");
}


int main()
{
  
 printf("hello world\n");
  atexit(fun2);
  atexit(fun1);
  printf("this is process\n");

 //return 0;
 exit(0);
 // _exit(0);


}

3.进程环境

环境变量

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

#include <stdlib.h>
#include <stdio.h>
// char *getenv(const char *name);


int main()
{
 char *name;
 //char array[10] = {"PATH"};
 name = getenv("PATH");
 printf("%s\n",name);

 return 0;
}
~                   

4.进程运行的虚拟地址空间

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

(5)意义。进程隔离，提供多进程同时运行

5.进程的引入

什么是进程

(1)动态过程而不是静态实物
(2)进程就是程序的一次运行过程，一个静态的可执行程序a.out的一次运行过程（./a.out去运行到结束）就是一个进程。
(3)进程控制块PCB（process control block），内核中专门用来管理一个进程的数据结构。
 

进程ID

(1)getpid、getppid、getuid、geteuid、getgid、getegid

多进程调度原理

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

fork的内部原理

(1)进程的分裂生长模式。如果操作系统需要一个新进程来运行一个程序，那么操作系统会用一个现有的进程来复制生成一个新进程。老进程叫父进程，复制生成的新进程叫子进程。
(2)fork的演示
(3)fork函数调用一次会返回2次，返回值等于0的就是子进程，而返回值大于0的就是父进程。
(4)典型的使用fork的方法：使用fork后然后用if判断返回值，并且返回值大于0时就是父进程，等于0时就是子进程。
(5)fork的返回值在子进程中等于0，在父进程中等于本次fork创建的子进程的进程ID。

6.父子进程对文件的操作

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

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


int main()
{  
 
 // 首先打开一个文件
    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);
   

  return 0;
}
                                                              98,1          Bot

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

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

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


int main()
{

    pid_t  pi = -1;
    int fd = -1;
   //pid_t fork(void);
    pi = fork();
    if(pi > 0)
    {
     //父进程 
     //int open(const char *pathname, int flags);
     fd = open("1.txt",O_RDWR | O_APPEND);
     if(fd < 0)
     {

        perror("open");

        return -1;
     }

        printf("paren.\n");
    //ssize_t write(int fd, const void *buf, size_t count);

        write(fd,"hello",5);
       sleep(1);
    }
    else if(pi == 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);

  return 0;
}
    
                                                              1,1           Top

总结：

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

7.进程的诞生和消亡

进程的诞生

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

进程的消亡

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

僵尸进程

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

孤儿进程

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

8.父进程wait回收子进程

wait的工作原理

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

wait实战编程

(1)wait的参数status。status用来返回子进程结束时的状态，父进程通过wait得到status后就可以知道子进程的一些结束状态信息。

(2)wait的返回值pid_t，这个返回值就是本次wait回收的子进程的PID。当前进程有可能有多个子进程，wait函数阻塞直到其中一个子进程结束wait就会返回，wait的返回值就可以用来判断到底是哪一个子进程本次被回收了。
对wait做个总结：wait主要是用来回收子进程资源，回收同时还可以得知被回收子进程的pid和退出状态。

fork后wait回收实例

(4)WIFEXITED、WIFSIGNALED、WEXITSTATUS这几个宏用来获取子进程的退出状态。
WIFEXITED宏用来判断子进程是否正常终止（return、exit、_exit退出）
WIFSIGNALED宏用来判断子进程是否非正常终止（被信号所终止）
WEXITSTATUS宏用来得到正常终止情况下的进程返回值的。

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



int main(void)
{
	pid_t pid = -1;
	pid_t ret = -1;
	int status = -1;
	
	pid = fork();
	if (pid > 0)
	{
		// 父进程
		//sleep(1);
		printf("parent.\n");
		ret = wait(&status);
		
		printf("子进程已经被回收，子进程pid = %d.\n", ret);
		printf("子进程是否正常退出：%d\n", WIFEXITED(status));
		printf("子进程是否非正常退出：%d\n", WIFSIGNALED(status));
		printf("正常终止的终止值是：%d.\n", WEXITSTATUS(status));
	}
	else if (pid == 0)
	{
		// 子进程
		printf("child pid = %d.\n", getpid());
		return 51;
		//exit(0);
	}
	else
	{
		perror("fork");
		return -1;
	}
	
	return 0;
}

waitpid介绍

waitpid和wait差别

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

代码实例

(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（表示回收不成功）。

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



int main(void)
{
	pid_t pid = -1;
	pid_t ret = -1;
	int status = -1;
	
	pid = fork();
	if (pid > 0)
	{
		// 父进程
		sleep(1);
		printf("parent, 子进程id = %d.\n", pid);
		//ret = wait(&status);
		//ret = waitpid(-1, &status, 0);
		//ret = waitpid(pid, &status, 0);
		ret = waitpid(pid, &status, WNOHANG);		// 非阻塞式
		
		printf("子进程已经被回收，子进程pid = %d.\n", ret);
		printf("子进程是否正常退出：%d\n", WIFEXITED(status));
		printf("子进程是否非正常退出：%d\n", WIFSIGNALED(status));
		printf("正常终止的终止值是：%d.\n", WEXITSTATUS(status));
	}
	else if (pid == 0)
	{
		// 子进程
		//sleep(1);
		printf("child pid = %d.\n", getpid());
		return 51;
		//exit(0);
	}
	else
	{
		perror("fork");
		return -1;
	}
	
	return 0;
}

竟态初步引入

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