exec系列函数和system函数

最新推荐文章于 2024-06-06 16:03:29 发布
最新推荐文章于 2024-06-06 16:03:29 发布
阅读量453 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eric_qiushui/article/details/90231839
版权

文章目录

一、exec替换进程映象

在进程的创建上Unix采用了一个独特的方法，它将进程创建与加载一个新进程映象分离。这样的好处是有更多的余地对两种操作进行管理。当我们创建

了一个进程之后，通常将子进程替换成新的进程映象，这可以用exec系列的函数来进行。当然，exec系列的函数也可以将当前进程替换掉。

二、exec关联函数组

  1. 包含头文件

    <unistd.h>

  2. 功能

    用exec函数可以把当前进程替换为一个新进程。

  3. 原型

      int execl(const char *path, const char *arg, ...);
  int execlp(const char *file, const char *arg, ...);
  int execle(const char *path, const char *arg,..., char * const envp[]);           
  int execv(const char *path, char *const argv[]);
  int execvp(const char *file, char *const argv[]);
  int execvpe(const char *file, char *const argv[], char *const envp[]);

  4. 参数
    path参数表示你要启动程序的名称包括路径名
    arg参数表示启动程序所带的参数

  5. 返回值

    成功，没有返回值----因为进程替换，他已经去执行别的进程，如果非要说，不妨说是替换进程的返回值，一个正常退出的程序的返回值为 0

    失败，返回-1

  6. 可分为两组

    execl，execlp，execle（都带l，可以将l理解为list）的参数个数是可变的，参数以一个空指针结束。

    execv、execvp和execvpe的第二个参数是一个字符串数组(可以理解为vector)。

    新程序在启动时会把在argv数组中给定的参数传递到main（不管是不是进程替换，main函数都是一个程序的入口函数）

  7. 关于函数的一些解释

    名字含字母“p”的函数会搜索PATH环境变量去查找新程序的可执行文件。如果可执行文件不在PATH定义的路径上，就必须把包括子目录在内的绝对文件名做为一个参数传递给这些函数。

    名字最后一个字母为"e"的函数可以自设环境变量。

  8. 关于这一些列函数的实现

    这些函数通常都是用execve实现的，这是一种约定俗成的做法，并不是非这样不可。

     int execve(const char *filename, char *const argv[], char *const envp[]);

    注意，前面6个函数都是C库函数，而execve是一个系统调用。
    六个exec函数之间的关系如下图：
    六个exec函数之间的关系

三、执行exec函数，下面属性是不发生变化的

  1. 进程ID和父进程ID（pid, ppid）
  2. 实际用户ID和实际组ID（ruid, rgid）
  3. 附加组ID（sgid）
  4. 会话ID
  5. 控制终端
  6. 闹钟余留时间
  7. 当前工作目录
  8. 根目录
  9. umask
  10. 文件锁
  11. 进程信号屏蔽
  12. 未处理信号
  13. 资源限制
  14. 进程时间

四、执行exec函数，将会发生变化的属性

  1. 关于 文件描述符的close-on-exec属性

    文件描述符如果存在close-on-exec标记的话，那么打开的文件描述符会被关闭。

  2. 如果可执行程序文件存在SUID和SGID位的话，那么有效用户ID和组ID（euid, gid）会发生变化

  3. 关于信号处理方式

    程序启动的时候，所有的信号处理方式都是默认的。

    对fork来说，因为子进程和父进程的地址空间是一样的，所以信号处理方式保留了下来。

    接下来进行exec,会将所有设置成为捕捉的信号都修改成为默认处理，而原来已经设置成为忽略的信号就不发生改变。

  4. 示例

    我们写一个简单的小程序，演示一下exec函数的用法，我们拿 execle 举例吧

    /**
 * filename instanceOfExec.cpp
 * author   zbq
 * date     2019.05.15
 * */
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <unistd.h>
#include <sys/wait.h>

static const char * env_init[] = {"USER=root", "PATH=/root/study/apue", NULL};

int main(void)
{
    pid_t pid = 0;

    pid = fork();

    if(pid < 0)
    {
        std::cerr << "fork() faild " << std::endl;
        exit(1);
    }
    else if(pid == 0)
    {
        int ret_exec = execle("/usr/bin/echo", "echo", "hahaha, I'm from exec!!!", (char*)0);
        if(ret_exec < 0)
        {
            std::cerr << "execle() faild -_-|" << std::endl;
            exit(-1);
        }
        exit(0);
    }
    else
    {
        pid_t ret_wait = waitpid(pid, nullptr, 0);
        if(ret_wait < 0 || ret_wait != pid)
        {
            std::cerr << "waitpid() faild" << std::endl;
            exit(2);
        }
    }

    return 0;
}

    我们编译之：

     g++ instanceOfExec.cpp -std=c++11

    运行之：

    ./a.out

    exec函数实例
    我们成功打印出了hahaha, I'm from exec!!!，这和在bash上输入 echo "hahaha, I'm from exec!!!"是一样的。

  5. 我们用strace命令来看一下这个过程是怎么样的

    execve("./a.out", ["./a.out"], [/* 24 vars */]) = 0
brk(NULL)                               = 0x12f2000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f83d45ce000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=48797, ...}) = 0
mmap(NULL, 48797, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f83d45c2000
close(3)                                = 0
open("/lib64/libstdc++.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0 \262\5\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=991616, ...}) = 0
mmap(NULL, 3171168, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f83d40a7000
mprotect(0x7f83d4190000, 2093056, PROT_NONE) = 0
mmap(0x7f83d438f000, 40960, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0xe8000) = 0x7f83d438f000
mmap(0x7f83d4399000, 82784, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f83d4399000
close(3)                                = 0
open("/lib64/libm.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\20S\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=1137024, ...}) = 0
mmap(NULL, 3150120, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f83d3da5000
mprotect(0x7f83d3ea6000, 2093056, PROT_NONE) = 0
mmap(0x7f83d40a5000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x100000) = 0x7f83d40a5000
close(3)                                = 0
open("/lib64/libgcc_s.so.1", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\220*\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=88776, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f83d45c1000
mmap(NULL, 2184192, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f83d3b8f000
mprotect(0x7f83d3ba4000, 2093056, PROT_NONE) = 0
mmap(0x7f83d3da3000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x14000) = 0x7f83d3da3000
close(3)                                = 0
open("/lib64/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\340$\2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2151672, ...}) = 0
mmap(NULL, 3981792, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f83d37c2000
mprotect(0x7f83d3984000, 2097152, PROT_NONE) = 0
mmap(0x7f83d3b84000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1c2000) = 0x7f83d3b84000
mmap(0x7f83d3b8a000, 16864, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f83d3b8a000
close(3)                                = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f83d45c0000
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f83d45be000
arch_prctl(ARCH_SET_FS, 0x7f83d45be740) = 0
mprotect(0x7f83d3b84000, 16384, PROT_READ) = 0
mprotect(0x7f83d3da3000, 4096, PROT_READ) = 0
mprotect(0x7f83d40a5000, 4096, PROT_READ) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f83d45bd000
mprotect(0x7f83d438f000, 32768, PROT_READ) = 0
mprotect(0x600000, 4096, PROT_READ)     = 0
mprotect(0x7f83d45cf000, 4096, PROT_READ) = 0
munmap(0x7f83d45c2000, 48797)           = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f83d45bea10) = 4573
wait4(4573, hahaha, I'm from exec!!!
NULL, 0, NULL)              = 4573
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=4573, si_uid=0, si_status=0, si_utime=0, si_stime=0} ---
exit_group(0)                           = ?
+++ exited with 0 +++

    在51，52行我们看到fork函数是调用clone函数创建4573号子进程的，然后子进程替换，父进程等待4573号进程退出，当子进程退出的时候，操作系统会给父进程发送SIGCHILD信号，父进程检测到该信号，就知道有子进程退出了。

五、system函数

  1. 功能

    system函数调用/bin/sh -c command执行特定的命令，阻塞当前进程直到command命令执行完毕

  2. 原型

    int system(const char *command);

  3. 返回值

    如果无法启动shell运行命令，system将返回127；

    出现不能执行system调用的其他错误时,返回-1；

    如果system能够顺利执行，返回那个命令的退出码。

  4. system函数执行时，会调用fork、execve、waitpid等函数。

  5. 示例

    /**
 * filename testSystem.cpp
 * author   zbq
 * date     2019.05.15
 * */
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>

int main(void)
{
    system("/usr/bin/echo \"hahaha, I'm from system function!\"");

    return 0;
}

    我们编译之：

     g++ testSystem.cpp

    运行之：

     ./a.out

    得到结果：

    system函数实例

    我们利用strace命令来看看system函数如何运作起来的

    execve("./a.out", ["./a.out"], [/* 24 vars */]) = 0
brk(NULL)                               = 0x1c20000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fdc4a002000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=48797, ...}) = 0
mmap(NULL, 48797, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fdc49ff6000
close(3)                                = 0
open("/lib64/libstdc++.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0 \262\5\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=991616, ...}) = 0
mmap(NULL, 3171168, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fdc49adb000
mprotect(0x7fdc49bc4000, 2093056, PROT_NONE) = 0
mmap(0x7fdc49dc3000, 40960, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0xe8000) = 0x7fdc49dc3000
mmap(0x7fdc49dcd000, 82784, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fdc49dcd000
close(3)                                = 0
open("/lib64/libm.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\20S\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=1137024, ...}) = 0
mmap(NULL, 3150120, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fdc497d9000
mprotect(0x7fdc498da000, 2093056, PROT_NONE) = 0
mmap(0x7fdc49ad9000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x100000) = 0x7fdc49ad9000
close(3)                                = 0
open("/lib64/libgcc_s.so.1", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\220*\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=88776, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fdc49ff5000
mmap(NULL, 2184192, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fdc495c3000
mprotect(0x7fdc495d8000, 2093056, PROT_NONE) = 0
mmap(0x7fdc497d7000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x14000) = 0x7fdc497d7000
close(3)                                = 0
open("/lib64/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\340$\2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2151672, ...}) = 0
mmap(NULL, 3981792, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fdc491f6000
mprotect(0x7fdc493b8000, 2097152, PROT_NONE) = 0
mmap(0x7fdc495b8000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1c2000) = 0x7fdc495b8000
mmap(0x7fdc495be000, 16864, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fdc495be000
close(3)                                = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fdc49ff4000
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fdc49ff2000
arch_prctl(ARCH_SET_FS, 0x7fdc49ff2740) = 0
mprotect(0x7fdc495b8000, 16384, PROT_READ) = 0
mprotect(0x7fdc497d7000, 4096, PROT_READ) = 0
mprotect(0x7fdc49ad9000, 4096, PROT_READ) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fdc49ff1000
mprotect(0x7fdc49dc3000, 32768, PROT_READ) = 0
mprotect(0x600000, 4096, PROT_READ)     = 0
mprotect(0x7fdc4a003000, 4096, PROT_READ) = 0
munmap(0x7fdc49ff6000, 48797)           = 0
rt_sigaction(SIGINT, {SIG_IGN, [], SA_RESTORER, 0x7fdc4922c280}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGQUIT, {SIG_IGN, [], SA_RESTORER, 0x7fdc4922c280}, {SIG_DFL, [], 0}, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_PARENT_SETTID|SIGCHLD, parent_tidptr=0x7fff17e54140) = 4553
wait4(4553, hahaha, I'm from system function!
[{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 4553
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7fdc4922c280}, NULL, 8) = 0
rt_sigaction(SIGQUIT, {SIG_DFL, [], SA_RESTORER, 0x7fdc4922c280}, NULL, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=4553, si_uid=0, si_status=0, si_utime=0, si_stime=0} ---
exit_group(0)                           = ?
+++ exited with 0 +++

    我们注意看一下54和55行，先调用 clone 函数，之后调用 wait4 函数等待4553号进程退出，其实fork函数底层也是用clone函数实现的。

zhangbaqing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
exec函数和system函数
章飞 _906285288的博客
03-14 5132
exec函数和system函数 exec系列函数 system函数 exec系列函数首先讲一下exec，exec系列的函数主要是在代码中去执行可执行程序，类似android中的shellUtils,也就是去执行脚本语言或者执行程序在用fork函数创建子进程后，子进程往往要调用一种exec函数以执行另一个程序当进程调用一种exec函数时，该进程完全由新程序代换，替换原有进程的正文，而新程序则从其mai
文件系统与目录操作
u011616934的博客
02-05 533
文件系统与目录操作
Linux_进程间通信_内存映射
最新发布
noobodybwq的博客
06-06 263
内存映射（Memory-mapped I/O）是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。
[c/c++]6. exec函数
Escaping
02-20 3140
exec image.png 曾提及用fork函数创建新的子进程后，子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程执行的程序完全替换为新程序，而新程序则从其main函数开始执行。因为调用exec并不创建新进程，所以前后的进程ID并未改变。exec只是用磁盘 上的一个新程序替换了当前进程的正文段、数据段、堆段和栈段。 有7种不同的e...
【Linux高级 I/O（5）】初识存储映射 I/O——mmap()和 munmap()（附代码示例）
cj_lsk的博客
05-23 1870
对于这个问题的答案，我们首先需要了解到，对于 mmap()函数来说， 当文件成功被映射到内存区域时，这段内存区域（映射区）的大小通常是页大小的整数倍，即使参数 length 并不是页大小的整数倍。存储映射 I/O（memory-mapped I/O）是一种基于内存区域的高级 I/O 操作，它能将一个文件映射到进程地址空间中的一块内存区域中，当从这段内存中读数据时，就相当于读文件中的数据（对文件进行 read 操 作），将数据写入这段内存时，则相当于将数据直接写入文件中（对文件进行 write 操作）。
linux的exec和system函数介绍及选择
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
07-28 2282
在应用程序中有时候需要调用第三方的应用，这是常见的需求。此时可以使用linux下的exec命令或system命令达到目的。但是这两个该选择哪个呢？有什么区别？下面总结介绍下。
Linux下的系统编程——系统调用（五）
妄北y
08-25 2546
由操作系统实现并提供给外部应用程序的编程接口。系统调用就是应用程序同系统之间数据交互的桥梁。
PHP中exec函数和shell_exec函数的区别
12-19
6. **其他替代方案**：除了`exec`和`shell_exec`，PHP还有其他类似函数，如`system`、`passthru`等，它们在不同场景下各有优缺点，选择时需根据需求和安全性考虑。 总之，`exec`和`shell_exec`都是PHP中执行系统...
system函数.docx
06-11
总结起来，`system`函数适合执行简单的shell命令，而`exec`族函数则用于程序之间更复杂的交互和进程替换。了解它们的工作原理和使用场景对于编写高效的C程序至关重要。在实际编程中，应根据具体需求选择合适的函数，...
php中使用exec,system等函数调用系统命令的方法(不建议使用,可导致安全问题)
12-18
这时，PHP提供了一系列内置函数，如`exec`、`system`、`passthru`和`escapeshellcmd`，允许我们调用系统命令。然而，这些功能强大的函数同时也伴随着潜在的安全风险，因此在实际应用中需谨慎使用。 `exec`函数用于...
C语言进阶system函数.rar-综合文档
05-11
在C语言中，`system`函数是一个非常实用的工具，它允许程序员在程序运行时执行操作系统命令。这个功能强大的函数通常被用来启动另一个...在实际编程中，根据具体需求选择合适的函数和方法，以实现高效且安全的代码。
20120618_启动新进程(fork和exec系列函数实现)1
08-04
本文将深入探讨两个重要的函数，`fork()`和`exec()`系列函数，它们在启动新进程时起着至关重要的作用。 **一、复制进程映像：fork()函数** `fork()`函数是Unix和类Unix系统（如Linux）中用于创建新进程的关键系统...
Linux系统编程（exec函数家族和system函数）
m0_49476241的博客
06-25 1482
本篇文章我们继续讲解多进程编程中的，exec函数家族和system函数。system 函数是一个标准库函数，用于在C和C++程序中执行命令行命令。它通过调用操作系统提供的相关机制来在新的子进程中执行指定的命令，并等待命令执行完成后返回。其中，command 是一个指向以 null 结尾的字符串的指针，表示要执行的命令。函数返回一个表示命令执行结果的整数值。1.创建一个新的子进程。2.在子进程中调用操作系统提供的函数来执行指定的命令。3.父进程等待子进程执行完成。
linux系统编程之进程（三）：exec系列函数和system函数
Meditation
05-15 5449
一、exec替换进程映象 在进程的创建上Unix采用了一个独特的方法，它将进程创建与加载一个新进程映象分离。这样的好处是有更多的余地对两种操作进行管理。当我们创建了一个进程之后，通常将子进程替换成新的进程映象，这可以用exec系列的函数来进行。当然，exec系列的函数也可以将当前进程替换掉。 二、exec关联函数组 包含头文件 功能用exec函数可以把当前进程替换为一个新进程。exec
system函数 与 exec函数的区别
Little devil
10-21 1371
system是用shell来调用程序=fork+exec+waitpid，而exec是直接让你的程序代替用来的程序运行。 system 是在单独的进程中执行命令，完了还会回到你的程序中。而exec函数是直接在你的进程中执行新的程序，新的程序会把你的程序覆盖，除非调用出错，否则你再也回不到exec后面的代码，就是说你的程序就变成了exec调用的那个程序了。 看一下，下面的例子. 例子1 ------
exec家族与system函数
weixin_42136255的博客
03-21 303
exec家族与system函数
mmap内存映射（共享内存实现进程通信）
qq_40631424的博客
03-07 159
linxu
c语言多线程拷贝,linuc下实现多线程拷贝文件（C语言版本）
weixin_42345036的博客
05-22 681
网上已经有很多代码，本来打算理解一下别人的代码，拷贝过来执行就可以了，但是找了两个博客的代码，执行都报错了，于是就研究了一下mmap实现多线程拷贝，参考https://blog.csdn.net/woshichaoren1/article/details/85227528https://www.cnblogs.com/lianshuiwuyi/p/7506972.html实现了，代码有些不精简，可...
system函数和popen函数
qq_46777053的博客
09-23 275
Linux的system函数的实现源码 system()会调用fork()产生子进程，由子进程来调用/bin/sh-c cmdstring来执行参数cmdstring字符串所代表的命令，此命令执行完后随即返回原调用的进程。 int system(const char * cmdstring) { pid_t pid; int status; if(cmdstring == NULL){ return (1); } if((
Linux文件操作命令mv的C语言实现。 mv：移动文件或目录 说明：不能使用system函数或exec系列函数
05-30
可以使用C语言中的系统调用函数rename()来实现mv命令的功能，具体实现如下： ``` #include #include #include #include int main(int argc, char *argv[]) { // 必须输入两个参数，否则报错 if (argc != 3) ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值