Linux进程的创建结束类系统调用总结

最新推荐文章于 2023-05-10 20:12:29 发布
最新推荐文章于 2023-05-10 20:12:29 发布
阅读量786 收藏 1
点赞数
分类专栏： OS Linux & Shell 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41437512/article/details/129283902
版权

tags: Linux OS Syscall C

写在前面

总结一下Linux系统的进程创建/终止/等待等系统调用, 参考:

  1. Linux/Unix系统编程手册.

下面主要给出例子, 关于函数原型可以参考书中或者man 2 syscall(例如man 2 fork).

测试环境: Ubuntu 20.04 x86_64

gcc-9

进程创建: fork()

用于创建新的进程, 创建出来的新进程称为子进程, 拥有和父进程一样的代码段/数据段/栈段/堆段.

所以创建新进程的资源消耗较大, 后续采用多线程方式可以解决这个问题.

由于这个函数的设计比较奇怪, 有两个返回值, 在父进程中返回子进程的进程ID, 在子进程中返回0, 错误返回-1, 所以可以用下面的语句制定创建子进程之后的进一步操作:

pid_t childPid;

switch (childPid = fork()) {
    case -1:
        /* error handling */
    case 0: // child process
        /* actions to child */
    default:
        /* actions to parent */
}

下面主要讨论数据共享和文件(句柄)共享, 为探讨进程间通信做准备.

数据共享

一个例子, 关于同时操作一份数据:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h> // pid_t
#include <unistd.h>    // fork
static int idata = 111;

int main(int argc, char *argv[]) {
    pid_t childPId;
    int istack = 222;

    switch (childPId = fork()) {
        case -1:
            fprintf(stderr, "fork error\n");
        case 0:
            idata *= 3;
            istack *= 3;
            break;
        default:
            sleep(3);
            break;
    }

    printf("PID=%ld %s idata=%d istack=%d\n", (long)getpid(),
           (childPId == 0) ? "(child) " : "(parent)", idata, istack);
    /* PID=526436 (child)  idata=333 istack=666 */
    /* PID=526435 (parent) idata=111 istack=222 */

    return 0;
}

文件共享

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

int main(int argc, char* argv[]) {
    int fd, flags;
    char template[] = "/tmp/test-XXXXXX";
    setbuf(stdout, NULL);// 无缓冲

    fd = mkstemp(template);
    if (fd == -1) fprintf(stderr, "mkstemp");

    printf("File offset before fork: %lld\n",
           (long long)lseek(fd, 0, SEEK_CUR));

    flags = fcntl(fd, F_GETFL);

    if (flags == -1) fprintf(stderr, "fcntl - F_GETFL");
    printf("O_APPEND flag before fork() is %s\n",
           (flags & O_APPEND) ? "on" : "off");

    switch (fork()) {
        case -1:
            fprintf(stderr, "fork");
        case 0: // child
            if (lseek(fd, 1000, SEEK_SET) == -1) fprintf(stderr, "lseek");
            flags = fcntl(fd, F_GETFL);
            if (flags == -1) fprintf(stderr, "fcntl - F_GETFL");
            flags |= O_APPEND;
            if (fcntl(fd, F_SETFL, flags) == -1)
                fprintf(stderr, "fcntl - F_SETFL");
            _exit(EXIT_SUCCESS);
        default: // parent
            if (wait(NULL) == -1) fprintf(stderr, "wait");
            printf("child has exited\n");

            printf("file offset in parent is %lld\n",
                   (long long)lseek(fd, 0, SEEK_CUR));

            flags = fcntl(fd, F_GETFL);
            if (flags == -1) fprintf(stderr, "fcntl - F_GETFL");

            printf("O_APPEND in parent is %s\n",
                   (flags & O_APPEND) ? "on" : "off");
            exit(EXIT_SUCCESS);
    }
    return 0;
}
/* :!cc fork-file-shared.c && ./a.out */
/* File offset before fork: 0 */
/* O_APPEND flag before fork() is off */
/* child has exited */
/* file offset in parent is 1000 */
/* O_APPEND in parent is on */

新进程创建-节约资源版: vfork()

最好不要用vfork

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

int main(int argc, char *argv[]) {
    int istack = 222;
    switch (vfork()) {
        case -1:
            fprintf(stderr, "vfork");
            exit(1);
        case 0: // child
            sleep(3);
            write(STDOUT_FILENO, "child executing\n", 16);
            istack *= 3;
            _exit(EXIT_SUCCESS);
        default:
            write(STDOUT_FILENO, "Parent executing\n", 17);
            printf("istack=%d\n", istack);
            exit(EXIT_SUCCESS);
    }
    return 0;
}
// 子进程对变量的修改影响了父进程的对应变量

/* child executing */
/* Parent executing */
/* istack=666 */

子进程会共享父进程的内存, 父进程会一直挂起直到子进程终止或者调用exec

fork竞态条件与同步

竞态条件

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

int main(int argc, char *argv[]) {
    int numChild, j;
    pid_t childPid;

    numChild = 100;
    setbuf(stdout, NULL); // 关闭缓存
    for (j = 0; j < numChild; ++j) {
        switch (childPid = fork()) {
            case -1:
                fprintf(stderr, "fork\n");
            case 0: // child
                printf("%d child\n", j);
                _exit(EXIT_SUCCESS);
            default: // parent
                printf("%d parent\n", j);
                wait(NULL);
                break;
        }
    }
    return 0;
}

几乎全是父进程先输出结果, 然后是子进程. 这就说明在Linux中fork执行之后会继续执行父进程, 而不是子进程.

不过, 这也取决于内核的调度算法实现.

所以不要对fork之后父子进程的执行顺序做任何假设, 如果一定要确保某一特定的执行顺序, 一定要采用某种进程间通信技术(同步技术), 例如: 文件锁, 信号量, 消息传送(基于管道, pipe).

使用信号机制解决进程竞态条件

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

#define BUF_SIZE 1000
#define SYNC_SIG SIGUSR1 /* Synchronization signal */

static void /* Signal handler - does nothing but return */
handler(int sig) {}

char *currTime(const char *format) {
    static char buf[BUF_SIZE]; /* Nonreentrant */
    time_t t;
    size_t s;
    struct tm *tm;

    t = time(NULL);
    tm = localtime(&t);
    if (tm == NULL) return NULL;

    s = strftime(buf, BUF_SIZE, (format != NULL) ? format : "%c", tm);

    return (s == 0) ? NULL : buf;
}

int main(int argc, char *argv[]) {
    pid_t childPid;
    sigset_t blockMask, origMask, emptyMask;
    struct sigaction sa;

    setbuf(stdout, NULL); /* Disable buffering of stdout */

    sigemptyset(&blockMask);
    sigaddset(&blockMask, SYNC_SIG); /* Block signal */
    if (sigprocmask(SIG_BLOCK, &blockMask, &origMask) == -1)
        fprintf(stderr, "sigprocmask");

    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sa.sa_handler = handler;
    if (sigaction(SYNC_SIG, &sa, NULL) == -1) fprintf(stderr, "sigaction");

    switch (childPid = fork()) {
        case -1:
            fprintf(stderr, "fork");

        case 0: /* Child */

            /* Child does some required action here... */

            printf("[%s %ld] Child started - doing some work\n", currTime("%T"),
                   (long)getpid());
            sleep(2); /* Simulate time spent doing some work */

            /* And then signals parent that it's done */

            printf("[%s %ld] Child about to signal parent\n", currTime("%T"),
                   (long)getpid());
            if (kill(getppid(), SYNC_SIG) == -1) fprintf(stderr, "kill");

            /* Now child can do other things... */

            _exit(EXIT_SUCCESS);

        default: /* Parent */

            /* Parent may do some work here, and then waits for child to
               complete the required action */

            printf("[%s %ld] Parent about to wait for signal\n", currTime("%T"),
                   (long)getpid());
            sigemptyset(&emptyMask);
            if (sigsuspend(&emptyMask) == -1 && errno != EINTR)
                fprintf(stderr, "sigsuspend");
            printf("[%s %ld] Parent got signal\n", currTime("%T"),
                   (long)getpid());

            /* If required, return signal mask to its original state */

            if (sigprocmask(SIG_SETMASK, &origMask, NULL) == -1)
                fprintf(stderr, "sigprocmask");

            exit(EXIT_SUCCESS);
    }
}

/* :!cc fork-sig-sync.c -Wall && ./a.out */
/* [20:01:11 742971] Parent about to wait for signal */
/* [20:01:11 742977] Child started - doing some work */
/* [20:01:13 742977] Child about to signal parent */
/* [20:01:13 742971] Parent got signal */

进程终止

exit和_exit

#include <unistd.h>

void _exit(int status); // syscall

status参数就是传入的终止状态.

#include <stdlib.h>

void exit(int status); // libc

会依次执行下面三个步骤:

  1. 调用退出处理程序: 通过atexit()和on_exit()注册的函数
  2. 刷新stdio流缓冲区
  3. 使用由status提供的值执行_exit()系统调用

执行return n;相当于执行exit(n);

进程终止后的细节

  1. 关闭所有打开的文件描述符, 目录流, 信息目录描述符以及转换描述符
  2. 释放进程持有的所有文件锁
  3. 分离任何已连接的System V共享内存段
  4. ...

注册退出处理程序

#include <stdlib.h>

int atexit(void (*func)(void)); // 出错返回非零值, 不一定为-1

其中传入的参数为一个参数列表和返回值均为void的函数指针.

atexit函数会将传入的func函数指针加入到一个函数列表中, 进程终止时会调用该函数列表的所有函数.

以及一个类似的库函数: (可以传入状态)

#include<stdlib.h>

int on_exit(void (*func)(int, void *), void *arg);

其中传入的参数为一个参数列表为int和指针, 返回值为void的函数指针.

例子

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

static void atexitFunc1(void) { printf("atexit func1 called\n"); }
static void atexitFunc2(void) { printf("atexit func2 called\n"); }

static void onexitFunc(int exitStatus, void *arg) {
    printf("on_exit func called: status=%d, arg=%ld\n", exitStatus, (long)arg);
}

int main(int argc, char *argv[]) {

    if (on_exit(onexitFunc, (void *)10)) fprintf(stderr, "on_exit 1\n");
    if (atexit(atexitFunc1)) fprintf(stderr, "atexit 1\n");
    if (atexit(atexitFunc2)) fprintf(stderr, "atexit 2\n");
    if (on_exit(onexitFunc, (void *)20)) fprintf(stderr, "on_exit 2\n");
    return 0;
}

/* on_exit func called: status=0, arg=20 */
/* atexit func2 called */
/* atexit func1 called */
/* on_exit func called: status=0, arg=10 */

监控子进程

wait(): 等待子进程的基本调用

等待调用进程的任一子进程终止, 同时在status所指向的缓冲区中返回子进程的终止状态.

#include<sys/wait.h>

pid_t wait(int *status);

wait()执行如下动作:

  1. 如果调用进程(指父进程)的一个(先前未等待的)子进程已经终止, 调用将一直阻塞, 直至某个子进程终止. 如果调用时已有子进程终止, wait将立即返回
  2. status非空, 则存入状态信息.
  3. 内核将为父进程下所有子进程的运行总量追加进程CPU时间以及资源使用数据.
  4. 将终止子进程的ID作为结果返回.

出错情况: (返回值为-1)

调用进程没有(先前未等待的)子进程, 此时errno置为ECHILD. 所以可以用下面代码检测所有子进程是否退出.

while (childPid = wait(NULL) != -1) continue;
if (errno != ECHILD) exit(1); // error

例子

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>
#include <sys/wait.h>
#define BUF_SIZE 1000
#define NUM 4
int times[NUM] = {0, 7, 1, 4};

char *currTime(const char *format) {
    static char buf[BUF_SIZE]; /* Nonreentrant */
    time_t t;
    size_t s;
    struct tm *tm;

    t = time(NULL);
    tm = localtime(&t);
    if (tm == NULL) return NULL;

    s = strftime(buf, BUF_SIZE, (format != NULL) ? format : "%c", tm);

    return (s == 0) ? NULL : buf;
}

int main(int argc, char *argv[]) {
    int numDead;
    pid_t childPid;
    int j;
    setbuf(stdout, NULL);
    for (j = 1; j < NUM; ++j) {
        switch (fork()) {
            case -1:
                fprintf(stderr, "fork\n");
            case 0:
                printf(
                    "[%s] child %d started with PID  %ld, sleeping %d "
                    "seconds\n",
                    currTime("%T"), j, (long)getpid(), times[j]);
                sleep(times[j]);
                _exit(0);
            default:
                break;
        }
    }
    numDead = 0;
    for (;;) {
        childPid = wait(NULL);
        if (childPid == -1) {
            if (errno == ECHILD) {
                printf("No more children -bye!\n");
                exit(0);
            } else {
                fprintf(stderr, "wait\n");
            }
        }
        numDead++;
        printf("[%s] wait() return child PID %ld (numDead=%d)\n",
               currTime("%T"), (long)childPid, numDead);
    }
}
/* [08:09:53] child 2 started with PID  825604, sleeping 1 seconds */
/* [08:09:53] child 1 started with PID  825603, sleeping 7 seconds */
/* [08:09:53] child 3 started with PID  825605, sleeping 4 seconds */
/* [08:09:54] wait() return child PID 825604 (numDead=1) */
/* [08:09:57] wait() return child PID 825605 (numDead=2) */
/* [08:10:00] wait() return child PID 825603 (numDead=3) */

waitpid(): 升级版的wait

wait存在以下的一些限制:

  1. 如果父进程已经创建了多个子进程, 使用wait将无法等待某一个确定的 子进程完成, 只能按顺序等待下一个子进程终止.
  2. 如果没有子进程退出, wait总是保持阻塞, 但是有时候会希望执行非阻塞等待.
  3. 使用wait只能发现那些已终止的子进程, 对于子进程因为哪个信号终止或者已停止的子进程收到SIGCONT信号后恢复执行的情况不得而知.
#include <sys/wait.h>

pid_t waitpid(pid_t pid, int *status, int options);

其中, 返回值和status参数的描述与wait相同, 下面是参数pid的含义:

  1. p i d > 0 pid>0 pid>0: 等待进程的PID为pid的子进程.
  2. p i d = 0 pid=0 pid=0: 等待与调用进程(父进程)同一个进程组的所有子进程.
  3. p i d < − 1 pid<-1 pid<−1: 等待进程组标识符与pid绝对值相等的所有子进程.
  4. p i d = − 1 pid=-1 pid=−1: 等待任意子进程. wait(&status);等价于waitpid(-1, &status, 0);.

参数options是一个位掩码, 可以包含(按位或操作)0个或多个如下标志:

  • WUNTRACED: 除了返回终止子进程的信息外, 还返回因信号而停止的子进程信息
  • WCONTINUED: 返回因收到SIGCONT信号而恢复执行的已停止子进程的状态信息
  • WNOHANG:
    • pid指定的子进程状态未改变, 返回, 不阻塞(poll,轮询), waitpid返回0.
    • 调用进程没有与pid匹配的子进程, 报错, errno=ECHILD.

程序的执行

execve: 将新程序加载到某一进程的内存空间

在这一过程中, 将丢弃旧有程序, 而进程的栈,数据以及堆内存都会被新程序的相应部件所替换.

在执行了各种C语言函数库的运行时启动代码以及程序的初始化代码之后, 新程序会从main()函数位置开始执行.

#include <unistd.h>

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

例子:

// envargs.c
#include <stdio.h>

extern char **environ;

int main(int argc, char *argv[]) {
    int j;
    char **ep;
    for (j = 0; j < argc; ++j) printf("argv[%d]=%s\n", j, argv[j]);
    for (ep = environ; *ep != NULL; ++ep) printf("environ: %s\n", *ep);
    return 0;
}

// execve-1.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    char *argVec[10];
    char *envVec[] = {"a=b", "c=d", NULL};
    argVec[0] = strrchr(argv[1], '/');
    if (argVec[0] != NULL)
        argVec[0]++;
    else
        argVec[0] = argv[1];
    argVec[1] = "hello";
    argVec[2] = "goodbye";

    argVec[3] = NULL;

    execve(argv[1], argVec, envVec);
    fprintf(stderr, "execve\n");
    return 0;
}

system: 执行系统命令

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

int main (int argc, char *argv[])
{
    system("ls | wc");
     /* 13      13     170 */
    return 0;
}
zorchp
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
进程的创建编写一段程序，使用系统调用fork（）创建两个子进程。当此程序运行时，
03-13
进程的创建 编写一段程序，使用系统调用fork（）创建两个子进程。当此程序运行时， 在系统中有一个父进程和两个子进程活动。 让每一个进程在屏幕上显示一个字符：父进程显示“A”； 子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果
CLion输出问题：使用printf(“请输入物品的数量和背包的容量：“)控制台无输出
拔牙不打麻药
06-05 2528
用CLion编写代码时，在最开始就写了printf("请输入物品的数量和背包的容量：")，然而直到全部输入完毕才出现printf中的内容。 解决方法：加入一句 setbuf(stdout,NULL); 就可以正常输出了。
setbuf()关闭缓冲
热门推荐
后台开发
11-08 1万+
setbuf函数用于打开和关闭缓冲机制，今天看看关闭缓冲区的功能。昨天在网上看到一个小程序，printf打印不出数据来，我们来看看。 #include int main(void) { int i=0; for(i=0;i<10;i++) { printf("haha"); sleep(1); } return
12.共享内存区介绍
行走
04-19 676
1、概述 共享内存区是可用IPC形式中最快的。一旦这样的内存区映射到共享它的进程的地址空间，这些进程间数据的传递就不再涉及内核。然而往该共享内存区存放信息或从中取走信息的进程间通常需要某种形式的同步。 2、mmap、munmap 和 msync 函数 （mmap性能总结 https://blog.csdn.net/qq_33611327/article/details/81738195） ...
Linux下的setbuf函数，关闭缓冲区？
weixin_36888577的博客
11-12 2655
Linux下不支持fflush刷新缓冲区，所以我们想到了setbuf函数，这随之而来的各种问题和小伙伴探讨之后得出如下结论 首先，网上有很多不同的言论，有的说setbuf只是刷新缓冲区，有的说会关闭缓冲区，众说纷纭，经过我们的测试和查找资料，如果你将stdin/stdout指向NULL，setbuf会关闭你的缓冲区，而不仅仅是刷新（查询度娘和man手册）。 例如：setbuf(stdin,NUL
setbuf函数使用注意事项
王教余的专栏
03-02 9908
程序输出有两种方式：一种是即时处理方式，另一种是先暂存起来，然后再大块写入的方式，前者往往造成较高的系统负担。因此，c语言实现通常都允许程序员进行实际的写操作之前控制产生的输出数据量。 这种控制能力一般是通过库函数setbuf实现的。如果buf是一个大小适当的字符数组，那么： setbuf(stdout，buf); 语句将通知输入/输出库，所有写入到stdout的输出都应该使用buf作为输出
标准IO函数 文件IO中的open函数 5.10
最新发布
weixin_45241469的博客
05-10 764
位于用户空间，是C库函数是带缓存的IO操作----缓存的目的是提高程序的效率FILE *：文件指针 指向内存中存放操作的文件信息的结构体stream：流指针文本流：操作数据是字符（ASCII）二进制流：操作的数据是 0 1 二进制全缓存：使用fflush、缓存区满、满足一定情况下行缓存：遇见’\n’、fflush、缓存区满了，满足一定情况​ 典型的行缓存：stdout 标准输出流无缓存：stderr缓存类型设置的函数：setbuf。
Unix/Linux编程：fork()进程详解
OceanStar的博客
11-25 4220
理论 进程 问： 什么是进程 一个程序的执行称为一个进程，所有的代码都是在进程中执行的。 进程也是操作系统进程资源分片的基本单位 问： 进程是怎么产生的 Linux中，除了内核启动进程之外，其他的进程都是由它的父进程产生的。【通过调用fork函数】 问：操作系统是怎么识别各个进程的 操心系统通过进程ID（pid）来识别，pid 是进程在操作系统中的唯一标志 pid是可以重复使用的，比如说前一个为pid=11的进程死掉了，那么pid=11的这个进程就可以分配给其他进程使用了：当pid达
linux进程系统调用
xurongxin2006的博客
10-17 661
linux进程系统调用函数使用详解
Posix共享内存
jinking01的专栏
11-25 798
1. 概述共享内存是可用IPC机制中最快的，2. mmap、munmap和msync函数mmapmmap函数把一个文件或一个Posix共享内存对象映射到调用进程的地址空间，使用该函数有三个目的：使用普通文件以提供内存映射IO使用特殊文件以提供匿名内存映射使用Posix共享内存对象以提供Posix共享内存区通常设为NULL，让内核自己决定起始地址它从被映射文件fd开头起第offset个字节处开始算，offset通常设为0，MAP_SHARED进程间共享内存需要使用MAP_SHARED。
【Linux】进程控制
weixin_74078718的博客
04-13 921
fork相关、写时拷贝、进程终止、进程等待、进程程序替换、替换函数等等内容
电子科大操作系统实验课Linux通过管道实现进程间通信
01-05
在Linux系统中使用系统调用fork()创建两个子进程，使用系统调用pipe()建立一个管道，两个子进程分别向管道各写一句话： Child process 1 is sending a message! Child process 2 is sending a message! 而父进程则...
进程控制（Linux）操作系统实验
06-25
设计并实现 Unix 的 “time” 命令。 “mytime” 命令通过命令行参数接受要运行的程序，创建一个独立的进程来运行该程序，并记录程序运行的...•使用 wait() 等待新创建的进程结束 •调用 gettimeofday() 来获取时间
操作系统课程实验.rar
01-15
由父进程创建一个管道，然后再创建 3 个子进程，并由这三个子进程利用管道与父进程 之间进行通信:子进程发送信息，父进程等三个子进程全部发完消息后再接收信息。通信的 具体内容可根据自己的需要随意设计，要求能...
什么是PHP7中的孤儿进程与僵尸进程
01-02
我们知道在unix/linux中，正常情况下，子进程是通过父进程创建的，子进程在创建新的进程。子进程的结束和父进程的运行是一个异步过程,即父进程永远无法预测子进程 到底什么时候结束。 当一个 进程完成它的工作终止...
操作系统课程设计进程控制
04-10
在Windows下实现: 使用CreateProcess()来创建进程 使用WaitForSingleObject()在“mytime”命令和新创建的进程之间同步 调用GetSystemTime()来获取时间 ...使用wait()等待新创建的进程结束 调用gettimeofday()来获取时间
联想小新+Windows10+Ubuntu18.04双系统安装+引导设置过程全记录
zorchp
05-13 1万+
Ubuntu双系统安装+引导方法详细总结。
gitignore文件详解
zorchp
01-05 1万+
-
multipass完全使用指南(M1 Mac)
zorchp
05-29 7554
-
linux系统调用函数大全
03-17
linux系统调用函数包括以下常用函数： - fork()：创建新进程 - exec()：在当前进程中执行新程序 - wait()：等待子进程结束 - exit()：终止当前进程 - open()：打开文件 - read()：读取文件 - write()：写入文件 - close()：关闭文件 - stat()：获取文件状态 - lseek()：改变文件指针的位置 - mmap()：映射文件到内存 - munmap()：取消内存映射 - chdir()：改变当前工作目录 - getcwd()：获取当前工作目录 - chmod()：改变文件权限 - chown()：改变文件所有者 - utime()：更改文件时间戳 这只是一些常用的系统调用函数，实际上linux系统还有很多其他系统调用函数可供使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zorchp

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

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

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

打赏作者

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

抵扣说明：

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

余额充值