C语言超详细分析多进程的概念与使用

目录

• 1.多进程相关概念
• 1.1什么是进程
• 1.2进程和程序有什么区别
• 1.3进程的组成
• 1.4进程的种类
• 1.5什么是进程的PID
• 1.6特殊PID的进程
• 1.7进程的状态
• 二.进程实例
• 2.1进程的拷贝
• 2.2进程创建的实例
• 2.3执行没有先后循序
• 2.4进程创建的实例(父子进程内存空间问题)
• 2.5使用多进程创建三个进程
• 2.6使用多进程进行拷贝文件
• 三.什么是孤儿进程与僵尸进程
• 3.1僵尸进程
• 3.2孤儿进程
• 四，守护进程的创建
• 4.1守护进程的创建
• 4.2步骤图
• 4.3代码实现

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

到此这篇关于C语言超详细分析多进程的概念与使用的文章就介绍到这了,更多相关C语言多进程内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！