1.多进程相关概念

1.1什么是进程？

进程：程序的一次执行过程就会产生一个进程。进程是分配资源的最小单位（0-3G）。

进程就是一个正在执行的任务。进程是一个动态的过程，它有生命周期随着程序的运行

开始，随着程序结束而消亡。每个进程都有自己的独立的运行的空间，比如每个进程都有

自己的文件描述符，每个进程都拥有自己的缓冲区。只要用户执行了一个程序，在内核空间

就会创建一个task_struct的结构体，这个结构体就代表当前的进程。进程运行产生的所有

的信息都被放到这个结构体中保存着。

1.2进程和程序有什么区别？

程序：程序是经过编译器编译生成的二进制文件，程序在硬盘上存储。程序是静态的，没有生命

​ 周期的概念程序本身不会分配内存。

进程：程序的一次执行过程就会创建一个进程，进程是动态的，有生命周期。进程运行的时候会

​ 分配0-3G的内存空间。进程在内存上存储。

1.3进程的组成？

进程是由三个部分组成的：进程的PCB（task_struct）,（程序段）文本段，数据段。

1.4进程的种类？

交互进程：这种进程维护以一个终端，通过这个终端用户可以和进程进程交互。

​ 例如：文本编辑器

批处理进程：这种进程优先级比较低，运行的时候会被放到一个运行的队列中。

​ 随着队列的执行，而逐渐执行。

​ 例如gcc编译程序的时候这个进程就是批处理进程。

守护进程：守护进程就是后台运行的服务，随着系统的启动而启动，随着系统的终止而终止。

​ 例如：windows上的各种服务

1.5什么是进程的PID

PID就是操作系统给进程分配的编号，它是识别进程的唯一的标识。

在linux系统中PID是一个大于等于0的值。

1.6特殊PID的进程

0：idle:在linux系统启动的时候运行的第一个进程就是0号进程。

​ 如果没有其他的进程执行就运行这个idle进程。

1:init:1号进程是由0号进程调用内核kernel_thread函数产生的第一个进程，

​ 它会初始化所有的系统的硬件。当初始化完之后会一直执行，比如会为

​ 孤儿进程回收资源。

2:kthreadd:调度器进程，主要负责进程的调度工作。

1.7进程的状态

 1.进程运行的状态
 D    // 不可中断的休眠态（信号）
    R    //运行态
    S    //可中断的休眠态（信号）
    T    //停止状态
    X    //死亡状态
    Z    //僵尸态（进程结束后没有被父进程回收资源）
2.进程的附加状态
   <    //高优先级
   N    //低优先级的进程
   L    //在内存区锁定
   s    //会话组组长
   l    //进中包含多线程
   +    //前台进程

二.进程实例：

2.1进程的拷贝：

#include 
 
int main(int argc,const char * argv[])
{
    for(int i=0;i<2;i++){
        fork();
        printf("-");
    }
    
    return 0;
}

原理图：

 

分析：上述的程序会打印8个-，上述程序一共是4个进程，因为在进程创建的时候会拷贝父进程的

缓冲区，由于2214和2215的缓冲区没有刷新，所以2216和2217缓冲区中有两个-。

2.2进程创建的实例

#include 
 
int main(int argc,const char * argv[])
{
    pid_t pid;
    pid = fork();
    if(pid == -1){
        PRINT_ERR("fork error");
    }else if(pid == 0){
        //子进程
        printf("这个就是子进程\n");
    }else{
        //父进程
        printf("这个就是父进程\n");
    }
    return 0;
}

分析图：

 2.3执行没有先后循序：

#include 
 
int main(int argc, const char* argv[])
{
    pid_t pid;
    pid = fork();
    if (pid == -1) {
        PRINT_ERR("fork error");
    } else if (pid == 0) {
        //子进程
        while (1) {
            sleep(1);
            printf("这个就是子进程\n");
        }
    } else {
        //父进程
        while (1) {
            sleep(1);
            printf("这个就是父进程\n");
        }
    }
    return 0;
}

结果图：
 

 

2.4进程创建的实例（父子进程内存空间问题）

父进程fork产生子进程的时候利用了写时拷贝的原则

 

2.5使用多进程创建三个进程：

#include 
#include 
#include 
#include 
int main(int argc, char const *argv[])
{
    pid_t pid;
    
    if((pid = fork()) ==-1){
        printf("创建进程失败\n");
        exit(-1);
    }else if(pid == 0){
        pid_t tid;
        if((tid = fork())==-1){
            printf("%d,%d\n",getpid(),getppid());
        }else if(pid == 0){
            printf("%d,%d\n",getpid(),getppid());
        }else{
            printf("%d\n",getpid());
        }
    }
 
    while(1);
    return 0;
}

2.6使用多进程进行拷贝文件：

#include 
#include 
#include 
#include 
#include 
#include 
 
char destfile[32]={0};
 
int get_length(char const *arcfile)
{
    int fd,cd,length;
 
    if((fd=open(arcfile,O_RDONLY))==-1){
        printf("open file error");
        exit(-1);
    }
 
    snprintf(destfile,sizeof(destfile),"new_%s",arcfile);
 
    if((cd==open(destfile,O_WRONLY|O_TRUNC|O_CREAT,0666)==-1)){
 
    }
 
    length = lseek(fd,0,SEEK_END);
 
    return length;
}
 
int copy_file(const char* srcfile,const char* destfile,int start,int length)
{
    int sfd,dfd,ret,count = 0;
    char buff[128] = {0};
    int counts=0;
 
    if((sfd=open(srcfile,O_RDONLY))==-1){
        printf("open error");
    }
 
    if((dfd=open(destfile,O_WRONLY))==-1){
        printf("open file error");
    }
 
    lseek(sfd,start,SEEK_SET);
    lseek(dfd,start,SEEK_SET);
    
    while (1){
       ret = read(sfd,buff,sizeof(buff));
       if(ret == 0){
            break;
       } 
 
        count+=ret;
 
       if(count >= length){
            write(dfd,buff,length-(count-ret));
            break;
       }
 
       write(dfd,buff,ret);
    }
    
    return 0;
}
 
int main(int argc, char const *argv[])
{
    pid_t pid;
 
    if(argc!=2){
        printf("输入格式错误，请重新输入\n");
        exit(-1);        
    }
 
    int length = get_length(argv[1]);
    if(length < 0){
        printf("srcfile error\n");
        return -1;
    }
 
    if((pid=fork())==-1){
        printf("fork error");
        exit(-1);
    }else if(pid == 0){
        copy_file(argv[1],destfile,length/2,length-length/2);
    }else{
        copy_file(argv[1],destfile,0,length/2);
    }
 
    return 0;
}

三.什么是孤儿进程，什么是僵尸进程

3.1僵尸进程：

子进程结束之后，父进程没有为它回收资源，此时子进程就是僵尸进程

#include 
 
int main(int argc, const char* argv[])
{
    pid_t pid;
 
    pid = fork();
    if (pid == -1) {
        PRINT_ERR("fork error");
    } else if (pid == 0) {
        //子进程
    } else {
        //父进程
        while(1);
    }
    return 0;
}

3.2孤儿进程：

孤儿进程：父进程死掉之后，子进程就是孤儿进程，孤儿进程被init进程收养。

#include 
 
int main(int argc, const char* argv[])
{
    pid_t pid;
 
    pid = fork();
    if (pid == -1) {
        PRINT_ERR("fork error");
    } else if (pid == 0) {
        //子进程
        printf("pid = %d\n",getpid());
        while (1);
    } else {
        //父进程
    }
    return 0;
}

四，守护进程的创建：

4.1守护进程的创建

守护进程：相当于系统的服务，随着系统的启动而运行，随着系统的终止而终止。脱离了某个终端.

4.2步骤图：

 

4.3代码实现：

#include 
#include 
#include 
#include 
#include 
#include 
 
#define ERROR(msg) do{\
    printf("%s %s %d\n",__FILE__,__func__,__LINE__);\
    printf(msg);\
    exit(-1); \
}while(0)
 
int main(int argc, char const *argv[])
{
    pid_t pid;
 
    if ((pid == fork()) == -1){
        ERROR("fork error");
    }else if(pid == 0){
        
        int fd;
 
        setsid();
        chdir("/");
        umask(0);
 
        for(int i = 3; i < getdtablesize(); i++){
            close(i);
        }
 
        if((fd = open("my.log", O_RDWR, O_APPEND, O_CREAT, 0666)) == -1){
            ERROR("open error");
        }
 
        dup2(fd, 0);
        dup2(fd, 1);
        dup2(fd, 2);
 
        while(1){
            sleep(1);
            printf("我是子进程\n");
            fflush(stdout);
        }
 
    }else{
        printf("父亲进程已经结束....\n");
        exit(-1);
    }
    return 0;
}