亲宝软件园·资讯

展开

C语言多进程

lhb2998658795 人气: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;
}

加载全部内容

相关教程
猜你喜欢
用户评论