C语言：多进程的详细介绍

置顶向着太阳迎着光_

已于 2022-08-16 15:41:13 修改

阅读量4.2k

点赞数 14

分类专栏： c语言 IO进程文章标签： linux 运维服务器

于 2022-08-13 21:23:04 首次发布

本文链接：https://blog.csdn.net/a2998658795/article/details/126324352

版权

c语言同时被 2 个专栏收录

38 篇文章 6 订阅

订阅专栏

IO进程

8 篇文章 0 订阅

订阅专栏

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 <head.h>

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 <head.h>

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 <head.h>

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 <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
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 <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

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 <head.h>

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 <head.h>

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 <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>

#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;
}