Linux系统编程1、fork函数 getpid函数 父子进程共享 不共享2、execl换壳 -后台进程打印到文件 3、孤儿进程 僵尸进程 4、wait和waitpid回收子进程

最新推荐文章于 2024-05-12 08:52:10 发布
最新推荐文章于 2024-05-12 08:52:10 发布
阅读量86 收藏
点赞数 2
分类专栏： Linux系统编程 文章标签： linux 运维 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rrrrrrrrtgghyhbh/article/details/130450030
版权

1、fork函数

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


int main(int argc, char * argv[])
{
    printf("before fork1\n");
    printf("before fork2\n");
    printf("before fork3\n");
    printf("before fork4\n");
    printf("before fork5\n");
    printf("before fork6\n");
    pid_t pid1;
    pid1 = fork();
    if (pid1 == -1)
    {
        perror("fork error");
        exit(1);
    }
    else if (pid1 == 0) // 子进程
    {
        printf("---child is created---\n");
    }
    else if (pid1 > 0)
    {
        printf("---parent process--- : my child is %d\n", pid1);
    }

    printf("============end of file\n");

    return 0;
}

1、fork函数循环创建n个子进程 

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


int main(int argc, char *argv[])
{
    printf("before fork1\n");
    printf("before fork2\n");
    printf("before fork3\n");
    printf("before fork4\n");
    printf("before fork5\n");
    printf("before fork6\n");
    int i;
    pid_t pid1;
    for (i = 0; i < 5; ++i)
    {
        pid1 = fork();
        if (pid1 == -1)
        {
            perror("fork error");
            exit(1);
        }
        else if (pid1 > 0)
        {
            if (i == 0)
                printf("parent process: %d\n", getpid());
            usleep(1);
        }
        else
        {
            printf("I'm %d child procee: %d myparentpid %d\n", i + 1, getpid(), getppid());
            break;
        }
    }
    
    printf("====end of file====\n");

    return 0;
}

1、getpid函数

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


int main(int argc, char * argv[])
{
    printf("before fork1\n");
    printf("before fork2\n");
    printf("before fork3\n");
    printf("before fork4\n");
    printf("before fork5\n");
    printf("before fork6\n");
    pid_t pid1;
    pid1 = fork();
    if (pid1 == -1)
    {
        perror("fork error");
        exit(1);
    }
    else if (pid1 == 0) // 子进程
    {
        printf("---child is created---\n");
        printf("my pid: %d, my parent pid: %d\n", getpid(), getppid());
    }
    else if (pid1 > 0)
    {
        printf("---parent process--- : my child is %d\n", pid1);
        printf("my pid: %d, my parent pid: %d\n", getpid(), getppid());
    }

    printf("============end of file\n");

    return 0;
}

1、父子进程共享 不共享

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
// 定义1个全局变量
int var = 100; // 测试父子进程是否共享全局变量
// 不共享, 读时共享, 写时复制

int main(int argc, char *argv[])
{
    pid_t pid;
    pid = fork();

    if (pid == -1)
    {
        perror("fork error");
        exit(1);
    }
    else if (pid > 0)
    {
        // 父进程
        var = 288;
        printf("parent, var = %d\n", var);
        printf("I'm parent pid = %d, getppid = %d\n", getpid(), getppid());
    }
    else if (pid == 0)
    {
        // 子进程
        // var = 200;
        printf("I'm child pid = %d, ppid = %d\n", getpid(), getppid());
        printf("child, var = %d\n", var);
    }


    return 0;
}

2、execl换壳函数 -后台进程打印到文件

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

int main(int argc, char *argv[])
{
    // 重定向输出--某文件
    int fd1 = open(argv[1], O_RDWR | O_CREAT, 0644);
    if (fd1 == -1)
    {
        perror("open error");
        exit(1);
    }
    int fd2 = dup2(fd1, STDOUT_FILENO);
    if (fd2 == -1)
    {
        perror("dup2 error");
        exit(1);
    }
    // 执行ps aux
    int ret = execlp("ps", "ps", "-a", "-u", "-x", NULL);
    if (ret == -1)
    {
        perror("execlp error");
        exit(1);
    }


    return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    printf("----before fork1----\n");
    printf("----before fork2----\n");
    printf("----before fork3----\n");
    printf("----before fork4----\n");
    printf("----before fork5----\n");
    pid_t pid;
    int ret;
    pid = fork();
    if (pid == -1)
    {
        perror("fork error\n");
        exit(1);
    }
    else if (pid > 0)
    {
        sleep(1);
        printf("Father process: %d, child process: %d\n", getpid(), pid);
    }
    else
    {
        printf("child process: %d, myfather process: %d\n", getpid(), getppid());
        // ret = execl("./test", "./test", NULL);
        // ret = execl("./", "test", NULL);
        ret = execl("/bin/ls", "/bin/ls", NULL);
        if (ret == -1)
        {
            perror("execlp error");
            exit(1);
        }
    }
    printf("====end of file====\n");

    return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    printf("----before fork1----\n");
    printf("----before fork2----\n");
    printf("----before fork3----\n");
    printf("----before fork4----\n");
    printf("----before fork5----\n");
    pid_t pid;
    int ret;
    pid = fork();
    if (pid == -1)
    {
        perror("fork error\n");
        exit(1);
    }
    else if (pid > 0)
    {
        sleep(1);
        printf("Father process: %d, child process: %d\n", getpid(), pid);
    }
    else
    {
        printf("child process: %d, myfather process: %d\n", getpid(), getppid());
        // ret = execlp("ls", "ls", "-l", "-h", NULL); // NULL代表参数结束(手动加)
        ret = execlp("date", "date", NULL);
        if (ret == -1)
        {
            perror("execlp error");
            exit(1);
        }
    }
    printf("====end of file====\n");

    return 0;
}

3、 孤儿进程

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

int main(void)
{
    pid_t pid;
    pid = fork();
    if (pid == -1)
    {
        perror("fork error");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("I'm parent, my pid is = %d\n", getpid());
        sleep(9);
        printf("----parent going to die----\n");
    }
    else
    {
        while(1)
        {
            printf("I'm child, my parent pid = %d\n", getppid());
            sleep(1);
        }
    }

    return 0;
}

3、僵尸进程

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

int main(void)
{
    pid_t pid;
    pid = fork();
    if (pid == -1)
    {
        perror("fork error");
        exit(1);
    }
    else if (pid > 0)
    {
        while(1)
        {
            printf("I'm parent, pid = %d, my son pid = %d\n", getpid(), pid);
            sleep(1);
        }
    }
    else
    {
        
        printf("child, my parent = %d, going to sleep 10s\n", getppid());
        sleep(10);
        printf("----child die----\n");
    }

    return 0;
}

4、wait回收子进程 查看死因

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

int main(int argc, char *argv[])
{
    pid_t pid, wpid;
    pid = fork();

    int status; // 记录子进程死亡原因

    if (pid == -1)
    {
        perror("fork error");
        exit(1);
    }
    else if (pid > 0)
    {
        wpid = wait(&status);
        if (wpid == -1)
        {
            perror("wait error");
            exit(1);
        }
        printf("----parent wait(%d) finished\n", wpid); // 阻塞等待回收子进程(子不死, 父不回收)
        // 查看子进程死亡原因
        if (WIFEXITED(status)) // 子进程正常死亡的
            printf("子进程return值: %d\n", WEXITSTATUS(status));
        else if (WIFSIGNALED(status)) // 子进程被信号杀死的(非正常死亡)
            printf("子进程被%d号信号杀死\n", WTERMSIG(status));
        
    }
    else
    {
        printf("---child, myid = %d, my parent = %d, going to sleep 10s\n", getpid(), getppid());
        sleep(10);
        printf("-----------------child die------------------\n");

        return 73;
    }


    return 0;
}

4、waitpid指定回收子进程 

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

int main(int argc, char *argv[])
{
    // 循环创建多个子进程
    pid_t pid, wpid;
    int i;
    // int status; // 查看子进程死亡原因
    for (i = 0; i < 5; ++i)
    {
        pid = fork();
        if (pid == -1)
        {
            perror("fork error");
            exit(1);
        }
        else if (pid > 0)
        {
            if (i == 0)
                printf("I'm parent %d\n", getpid());
            // 父进程 // 指定回收第3个子进程
            if (i == 2)
            {
                sleep(5);
                wpid = waitpid(pid, NULL, WNOHANG); // 非阻塞式回收
                if (wpid == -1)
                {
                    perror("waitpid error");
                    exit(1);
                }
                printf("I'm parent, wait a child finish : %d\n", wpid); // 子进程没死
            }
        }
        else
        {
            // 子进程
            sleep(i);
            printf("I'm %dth child mypid = %d\n", i + 1, getpid());
            break;
        }
    }

    return 0;
}

4、waitpid无差别回收子进程 

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


int main(int argc, char *argv[])
{
    // 循环创建多个子进程
    pid_t pid, wpid;
    int i;
    // int status; // 查看子进程死亡原因
    for (i = 0; i < 5; ++i)
    {
        pid = fork();
        if (pid == -1)
        {
            perror("fork error");
            exit(1);
        }
        else if (pid > 0)
        {
            // 父进程
            wpid = waitpid(-1, NULL, WNOHANG); // 非阻塞式回收
            if (wpid == -1)
            {
                perror("waitpid error");
                exit(1);
            }
            printf("I'm parent, wait a child finish : %d\n", wpid); // 子进程没死
        }
        else
        {
            // 子进程
            sleep(i);
            printf("I'm %dth child\n", i + 1);
            break;
        }
    }

    return 0;
}

5、waitpid阻塞回收多个子进程

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

int main(int argc, char *argv[])
{
    // 循环创建多个子进程
    pid_t pid, wpid;
    int i;
    // int status; // 查看子进程死亡原因
    for (i = 0; i < 5; ++i)
    {
        pid = fork();
        if (pid == -1)
        {
            perror("fork error");
            exit(1);
        }
        else if (pid > 0)
        {
            if (i == 0)
                printf("I'm parent %d\n", getpid());
        }
        else
        {
            // 子进程
            sleep(i);
            printf("I'm %dth child mypid = %d\n", i + 1, getpid());
            break;
        }
    }
    if (i == 5) // 只有父进程才会1步1步++到5退出循环, 子进程直接break的
    {
        // 1次wait/waitpid只能回收1个子进程 形参>0指定回收某个 -1回收任意一个子进程
        while ((wpid = waitpid(-1, NULL, 0)) > 0) // 阻塞回收
        {
            if (wpid == -1)
            {
                perror("waitpid error");
                exit(1);
            }
            printf("waitpid(%d)\n", wpid);
        }
    }

    return 0;
}

5、waitpid非阻塞回收多个子进程 

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

int main(int argc, char *argv[])
{
    // 循环创建多个子进程
    pid_t pid, wpid;
    int i;
    // int status; // 查看子进程死亡原因
    for (i = 0; i < 5; ++i)
    {
        pid = fork();
        if (pid == -1)
        {
            perror("fork error");
            exit(1);
        }
        else if (pid > 0)
        {
            if (i == 0)
                printf("I'm parent %d\n", getpid());
        }
        else
        {
            // 子进程
            sleep(i);
            printf("I'm %dth child mypid = %d\n", i + 1, getpid());
            break;
        }
    }
    if (i == 5) // 只有父进程才会1步1步++到5退出循环, 子进程直接break的
    {
        // 1次wait/waitpid只能回收1个子进程 形参>0指定回收某个 -1回收任意一个子进程
        while ((wpid = waitpid(-1, NULL, WNOHANG)) >= 0) // 非阻塞回收
        {
            sleep(1);
            if (wpid == -1)
            {
                perror("waitpid error");
                exit(1);
            }
            printf("waitpid(%d)\n", wpid);
        }
    }

    return 0;
}

阶段练习(fork创建3子进程, execl分别执行, 父进程回收) 

 

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

int main(int argc, char *argv[])
{
    pid_t pid, wpid;
    int i, ret1, ret2, ret3;
    for (i = 0; i < 3; ++i)
    {
        pid = fork();
        if (pid == -1)
        {
            perror("fork error");
            exit(1);
        }
        else if (pid > 0)
        {
            if (i == 0)
                printf("Parent = %d\n", getpid());
        }
        else
        {
            printf("I'm %dth child = %d, myparent = %d\n", i + 1, getpid(), getppid());
            sleep(i);
            if (i == 0)
            {
                ret1 = execlp("ps", "ps", NULL);
                if (ret1 == -1)
                {
                    perror("execl error");
                    exit(1);
                }
            }
            else if (i == 1)
            {
                ret2 = execl("./a.out", "./a.out", NULL);
                if (ret2 == -1)
                {
                    perror("execl error");
                    exit(1);
                }
            }
            else
            {
                ret3 = execl("./b.out", "./b.out", NULL);
                if (ret3 == -1)
                {
                    perror("execl error");
                    exit(1);
                }
            }
            // break;
        }
    }
    if (i == 3) // 父进程回收3个子进程
    {
        while ((wpid = waitpid(-1, NULL, WNOHANG)) >= 0) // 非阻塞回收
        {
            printf("I'm parent waitpid %d\n", wpid);
            sleep(1);
        }
    }

    return 0;
}
汪呈祥
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
简单掌握Linux系统中fork()函数创建子进程的用法
12-25
使用fork()函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间，包括进程的上下文、代码段、进程堆栈、内存信息、打开的文件描述符、符号控制设定、进程优先级、进程组号、当前工作目录、...
fork()----父子进程共享
程序狗的成长之路
09-10 8339
fork（）会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，linux中引入了“写时复制“技术，也就是只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。在fork之后exec之前两个进程用的是相同的物理空间（内存区），子进程的代码段、数据段、堆栈都是指向父进程的物理空间，也就是说，两者的虚拟空间不同，但其对应的物理空间是同一个。当父子进
fork调用后，子进程与父进程是否共享变量
modi000的博客
12-20 2102
回顾fork调用 fork系统调用从已存在的进程中生成一个新的进程，这个新的进程就是子进程，我们可以通过fork系统调用的返回值来区分子进程还是父进程。 一个进程，包括代码、数据和分配给进程的资源。fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程。 我们的问题是，进程中的变量是否由父进程和子进程共享？ 背景 最开始我简单的认为，似乎是看视频里说的。对于只读变量，父进程和子进程是共享的。对于进行写操作的变量，父进程和子进程是独立。后来在自己做实验是发现这样一个现象，于是就进行了思考。...
【Linux 进程】fork父子进程间共享数据分析
modi000的博客
05-30 3710
之前我们通过fork()函数，得知了父子进程之间的存在着代码的拷贝，且父子进程都相互独立执行，那么父子进程是否共享同一段数据，即是否存在着数据共享。接下来我们就来分析分析父子进程是否存在着数据共享。 我们都知道，在linux下，内存存储的位置是全局变量，栈区，堆区，以及文件。字符常量区我们这里不作分析。下面我们依次以实际代码来验证它们是否存在着数据共享。所谓的父子进程数据共享，通俗点说就是父进程或者子进程对于数据的更改，会使得子进程或者父进程的数据同步更改。代码检测的思想是让父子进程中的一个修改数据，未对
fork函数&父子进程共享数据的研究&写时拷贝技术
modi000的博客
05-13 1322
一、fork函数原型 #include <unistd.h> //引用fork()时的头文件 pid_t fork(void); 返回值 pid_t是进程描述符，其实就是int类型，如果fork()函数调用失败，就返回-1. 成功调用fork()函数一次，返回两次——在父进程中返回子进程的pid(非0值)，在子进程中返回0. 函数功能 以当前进程作为父进程创建出一个新的子进程，并且将父进程的所有资源拷贝给子进程，这样子进程作为父进程的一个副本存在。父子进程几乎时完全相同的，但也有不同的如父子.
fork后父子进程共享资源
热门推荐
teffi的专栏
07-30 1万+
fork后父子进程共享资源Unix环境高级编程中8.3节中说，“子进程是父进程的副本。例如，子进程获得父进程数据空间、堆和栈的副本。注意，这是子进程所拥有的副本。父进程和子进程并不共享这些存储空间部分。父进程和子进程共享正文段。”书中还预留了例子说明子进程对变量所做的改变并不影响父进程中该变量的值。/** * fork.c * 探讨父子进程共享变量问题 **/#include <stdio.h
linux系统编程学习_(2)进程控制-- fork函数、exec函数族、回收子进程--孤儿进程僵尸进程、wait函数
小康先生的博客
09-08 267
linux系统编程学习_(2)进程控制-- fork函数、exec函数族、回收子进程–孤儿进程僵尸进程、wait函数 进程控制 fork()函数 创建一个子进程。 pid_t fork(void); pid_t类型是表示进程ID，但为了表示-1，它是有符号整型(0并不是有效进程ID，init最小，为1) 失败返回： -1 成功返回： 父进程返回子进程的ID(非负) 子进程返回0 getpid()函数、getppid()函数、getuid()函数、getgid()函数 获取当前进程ID pid_t ge
Linux应用编程和网络编程（5）------- 进程全解之父子进程
big_C的博客
05-15 1044
目录程序的开始和结束进程的引入 程序的开始和结束 1、程序的开始 (1)main函数由编译链接时的引导代码调用。操作系统下的应用程序其实在main执行前也需要先执行一段引导代码才能去执行main，我们写应用程序时不用考虑引导代码的问题，编译连接时（准确说是连接时）由链接器将编译器中事先准备好的引导代码给连接进去和我们的应用程序一起构成最终的可执行程序。 (2)运行时的加载器。加载器是操作系统中的程序，当我们去执行一个程序时（譬如./a.out，譬如代码中用exec族函数来运行）加载器负责将这个程序加载到内存
嵌入式Linux系统编程-》进程fork()/wait()/waitpid/exit()/等等与程序+面试题【第1天：12005字】
m0_45463480的博客
06-02 632
嵌入式Linux系统编程【1】 第一抢-》进程与程序 【1】 基本概念 【2】进程的组织方式 【3】进程的复刻（fork） 【4】 进程的状态 第二枪-》进程API 【5】 进程的创建 【6】进程的回收 【7】 加载并执行指定程序 第三枪-》僵尸进程 【8】概念 【9】产生的原因 【10】释放僵尸进程 第四枪-》面试题......
C语言的fork函数在Linux中的进程操作及相关面试题讲解
01-21
2.fork 函数被调用一次，但返回两次， 两次返回的唯一区别是子进程的返回值是 0, 而父进程的返回值是新子进程的 PID。 3.子进程和父进程继续执行 fork 调用之后的指令。 在上图的存储空间布局中，父子进程只共享正文...
Linux进程与线程实验，exec族函数、管道、消息队列、信号机制、共享内存等
07-06
（2）用fork（）函数创建子进程。 （3）复制一个进程，父进程通过管道发送给子进程，并呈现在屏幕上。应用函数msgget、msgrcv、msgsnd，读、写消息队列中的消息并打印输出。 （4）应用用消息队列实现简单的聊天程序...
使用C语言的fork()函数在Linux中创建进程的实例讲解
01-21
使用fork()函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间，包括进程的上下文、代码段、进程堆栈、内存信息、打开的文件描述符、符号控制设定、进程优先级、进程组号、当前工作目录、...
Linux中使用C语言的fork()函数创建子进程的实例教程
01-01
fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。 一个进程调用fork（）函数后，系统先给新的...
linux下的调试工具gdb的详细使用介绍
qq_75270497的博客
05-06 1021
详细介绍在linux下使用gdb的方法，每个步骤都举例说明，适合复习和新手入门，希望能为能够帮助到大家。
linux下的进程通信
最新发布
羊羊羊
05-12 493
进程通信详解、管道、命名管道、匿名管道...
Linux生成密钥对并配置免密访问
u014516208的博客
05-07 366
先生成私钥，再生成公钥。
Linux字符设备驱动(一) - 框架
滴水藏海
05-06 1042
字符设备驱动的注册
Linux网站服务
c5zm51zjr的博客
05-08 788
注:Discuz软件包安装2.5版本的，若没有需要去官网论坛上寻找，找到之后复制链接下载即可。网站架构:LAMP: Linux+Apache+MYSQL+PHP(系统+服务器程序+数据管理软件+中间软件)主配置文件:/etc/httpd/conf/httpd.conf。主目录:/var/www/html (源代码默认位置）子配置文件:/etc/httpd/conf.d/*注:网站a.org无需授权，b.org需要授权。网站:多个网页组合而成的一台网站服务器。URL:统一资源定位符，访问网站的地址。
将程序中的 fork 系统调用替换成 vfork 系统调用，检测父子进程 共享资源的情况。
05-22
在Linux系统中，`fork()`是创建子进程的系统调用之一。它会将当前进程（称为父进程）完全复制一份，包括代码、数据和堆栈等资源，形成一个新的进程（称为子进程）。而`vfork()`也是创建子进程的系统调用，但是它与`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

汪呈祥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值