linux创建进程的命令有哪些

发布时间：2023-03-13 10:09:01 作者：iii
来源：亿速云阅读：171

Linux创建进程的命令有哪些

在Linux系统中，创建进程是操作系统管理任务和资源的核心功能之一。进程是程序的执行实例，每个进程都有独立的内存空间和系统资源。Linux提供了多种方式来创建和管理进程，本文将详细介绍这些方法，包括命令行工具、系统调用以及脚本语言中的相关命令。

1. 命令行工具

1.1 `fork()` 和 `exec()` 系统调用

在Linux中，创建进程的最基本方法是使用fork()和exec()系统调用。fork()系统调用创建一个与父进程几乎完全相同的子进程，而exec()系统调用则用于替换当前进程的地址空间为新的程序。

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

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        execlp("/bin/ls", "ls", NULL);
    } else if (pid > 0) {
        // 父进程
        wait(NULL);
        printf("Child process finished.\n");
    } else {
        // fork失败
        perror("fork");
    }
    return 0;
}

1.2 `bash` 和 `sh` 命令

在命令行中，可以使用bash或sh命令来启动一个新的shell进程。这些命令通常用于执行脚本或启动交互式shell。

bash -c "echo Hello, World!"

1.3 `nohup` 命令

nohup命令用于在后台运行进程，即使终端关闭，进程也不会被终止。它通常与&符号一起使用，将进程放入后台。

nohup sleep 100 &

1.4 `disown` 命令

disown命令用于将当前shell中的作业从作业表中移除，使其在终端关闭后继续运行。

sleep 100 &
disown

1.5 `screen` 和 `tmux` 命令

screen和tmux是终端复用工具，允许用户在单个终端窗口中运行多个会话。它们可以用于创建和管理多个进程。

screen -S mysession
tmux new -s mysession

1.6 `at` 和 `cron` 命令

at命令用于在指定时间执行一次性任务，而cron用于定期执行任务。它们都可以用于创建和管理后台进程。

at now + 1 minute <<< "echo Hello, World!"
crontab -e

2. 系统调用

2.1 `fork()`

fork()系统调用创建一个与父进程几乎完全相同的子进程。子进程从fork()返回的地方开始执行，返回值是0，而父进程返回子进程的PID。

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

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        printf("Child process\n");
    } else if (pid > 0) {
        printf("Parent process\n");
    } else {
        perror("fork");
    }
    return 0;
}

2.2 `exec()`

exec()系列系统调用用于替换当前进程的地址空间为新的程序。常见的exec()函数包括execl()、execv()、execle()、execve()等。

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

int main() {
    execlp("/bin/ls", "ls", NULL);
    perror("execlp");
    return 0;
}

2.3 `clone()`

clone()系统调用类似于fork()，但提供了更多的控制选项，允许创建轻量级进程（线程）。

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

int child_func(void *arg) {
    printf("Child process\n");
    return 0;
}

int main() {
    char *stack = malloc(1024 * 1024);
    if (stack == NULL) {
        perror("malloc");
        exit(EXIT_FLURE);
    }

    pid_t pid = clone(child_func, stack + 1024 * 1024, CLONE_VM | SIGCHLD, NULL);
    if (pid == -1) {
        perror("clone");
        exit(EXIT_FLURE);
    }

    waitpid(pid, NULL, 0);
    free(stack);
    return 0;
}

2.4 `vfork()`

vfork()系统调用创建一个子进程，但与fork()不同，vfork()保证子进程先运行，直到它调用exec()或_exit()。

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

int main() {
    pid_t pid = vfork();
    if (pid == 0) {
        printf("Child process\n");
        _exit(0);
    } else if (pid > 0) {
        printf("Parent process\n");
    } else {
        perror("vfork");
    }
    return 0;
}

3. 脚本语言中的相关命令

3.1 Python

在Python中，可以使用os.fork()和os.exec()来创建和管理进程。

import os

pid = os.fork()
if pid == 0:
    os.execlp("ls", "ls")
else:
    os.wait()
    print("Child process finished.")

3.2 Perl

在Perl中，可以使用fork()和exec()函数来创建和管理进程。

my $pid = fork();
if ($pid == 0) {
    exec("ls");
} elsif ($pid > 0) {
    wait();
    print "Child process finished.\n";
} else {
    die "fork failed: $!";
}

3.3 Ruby

在Ruby中，可以使用fork()和exec()方法来创建和管理进程。

pid = fork do
  exec("ls")
end

Process.wait
puts "Child process finished."

4. 其他工具和命令

4.1 `systemd`

systemd是Linux系统的初始化系统和服务管理器。它提供了systemctl命令来管理服务进程。

systemctl start myservice
systemctl stop myservice

4.2 `init`

init是传统的Linux初始化系统，用于启动和管理系统进程。

/etc/init.d/myservice start
/etc/init.d/myservice stop

4.3 `upstart`

upstart是另一种初始化系统，用于启动和管理系统进程。

start myservice
stop myservice

4.4 `docker`

docker是一个容器化平台，允许用户创建和管理容器进程。

docker run -d --name mycontainer myimage
docker stop mycontainer

5. 进程管理命令

5.1 `ps`

ps命令用于显示当前系统中的进程状态。

ps aux

5.2 `top`

top命令用于实时显示系统中的进程状态。

top

5.3 `htop`

htop是top的增强版，提供了更友好的用户界面和更多的功能。

htop

5.4 `kill`

kill命令用于向进程发送信号，通常用于终止进程。

kill -9 PID

5.5 `pkill`

pkill命令用于根据进程名或其他属性向进程发送信号。

pkill -f myscript.sh

5.6 `killall`

killall命令用于根据进程名终止所有匹配的进程。

killall myscript.sh

6. 进程间通信

6.1 管道（Pipe）

管道是一种进程间通信机制，允许一个进程的输出作为另一个进程的输入。

ls | grep .txt

6.2 命名管道（Named Pipe）

命名管道是一种特殊的文件，允许不相关的进程进行通信。

mkfifo mypipe
echo "Hello" > mypipe &
cat mypipe

6.3 信号（Signal）

信号是一种进程间通信机制，用于通知进程发生了某个事件。

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

void handler(int sig) {
    printf("Received signal %d\n", sig);
}

int main() {
    signal(SIGINT, handler);
    while (1) {
        sleep(1);
    }
    return 0;
}

6.4 共享内存（Shared Memory）

共享内存是一种高效的进程间通信机制，允许多个进程共享同一块内存区域。

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    int shmid = shmget(IPC_PRIVATE, 1024, 0666 | IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FLURE);
    }

    char *shmaddr = shmat(shmid, NULL, 0);
    if (shmaddr == (char *)-1) {
        perror("shmat");
        exit(EXIT_FLURE);
    }

    sprintf(shmaddr, "Hello, World!");
    printf("Shared memory content: %s\n", shmaddr);

    shmdt(shmaddr);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

6.5 消息队列（Message Queue）

消息队列是一种进程间通信机制，允许进程通过消息进行通信。

#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct msgbuf {
    long mtype;
    char mtext[100];
};

int main() {
    int msgid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FLURE);
    }

    struct msgbuf msg;
    msg.mtype = 1;
    strcpy(msg.mtext, "Hello, World!");

    if (msgsnd(msgid, &msg, sizeof(msg.mtext), 0) == -1) {
        perror("msgsnd");
        exit(EXIT_FLURE);
    }

    if (msgrcv(msgid, &msg, sizeof(msg.mtext), 1, 0) == -1) {
        perror("msgrcv");
        exit(EXIT_FLURE);
    }

    printf("Received message: %s\n", msg.mtext);

    msgctl(msgid, IPC_RMID, NULL);
    return 0;
}

6.6 信号量（Semaphore）

信号量是一种进程间同步机制，用于控制对共享资源的访问。

#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    int semid = semget(IPC_PRIVATE, 1, 0666 | IPC_CREAT);
    if (semid == -1) {
        perror("semget");
        exit(EXIT_FLURE);
    }

    struct sembuf sb;
    sb.sem_num = 0;
    sb.sem_op = -1; // P操作
    sb.sem_flg = 0;

    if (semop(semid, &sb, 1) == -1) {
        perror("semop");
        exit(EXIT_FLURE);
    }

    printf("Semaphore acquired\n");

    sb.sem_op = 1; // V操作
    if (semop(semid, &sb, 1) == -1) {
        perror("semop");
        exit(EXIT_FLURE);
    }

    printf("Semaphore released\n");

    semctl(semid, 0, IPC_RMID);
    return 0;
}

7. 进程调度

7.1 `nice` 和 `renice`

nice命令用于调整进程的优先级，renice命令用于修改已运行进程的优先级。

nice -n 10 ./myscript.sh
renice 10 -p PID

7.2 `chrt`

chrt命令用于设置进程的调度策略和优先级。

chrt -f 99 ./myscript.sh

7.3 `taskset`

taskset命令用于将进程绑定到特定的CPU核心。

taskset -c 0 ./myscript.sh

8. 进程监控

8.1 `strace`

strace命令用于跟踪进程的系统调用和信号。

strace ./myscript.sh

8.2 `ltrace`

ltrace命令用于跟踪进程的库函数调用。

ltrace ./myscript.sh

8.3 `gdb`

gdb是一个强大的调试工具，可以用于调试和分析进程。

gdb ./myscript

8.4 `valgrind`

valgrind是一个内存调试和分析工具，可以用于检测内存泄漏和其他内存问题。

valgrind ./myscript

9. 进程资源限制

9.1 `ulimit`

ulimit命令用于设置和显示进程的资源限制。

ulimit -a
ulimit -n 1024

9.2 `cgroups`

cgroups（控制组）是Linux内核功能，用于限制、记录和隔离进程组的资源使用。

cgcreate -g cpu:/mygroup
cgset -r cpu.shares=512 mygroup
cgexec -g cpu:mygroup ./myscript.sh

9.3 `systemd-run`

systemd-run命令用于在特定的资源限制下运行进程。

systemd-run --scope -p MemoryMax=100M ./myscript.sh

10. 进程调试和分析

10.1 `perf`

perf是一个性能分析工具，可以用于分析进程的性能。

perf record ./myscript.sh
perf report

10.2 `stap`

stap（SystemTap）是一个动态跟踪工具，可以用于分析进程的行为。

stap -e 'probe process("/path/to/myscript").function("*") { println(pn()) }'

10.3 `bpftrace`

bpftrace是一个基于eBPF的跟踪工具，可以用于分析进程的行为。

bpftrace -e 'tracepoint:syscalls:sys_enter_execve { printf("%s\n", comm) }'

11. 进程安全

11.1 `chroot`

chroot命令用于将进程的根目录更改为指定的目录，限制其对文件系统的访问。

chroot /new/root /bin/bash

11.2 `seccomp`

seccomp（安全计算模式）是Linux内核功能，用于限制进程可以执行的系统调用。

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

int main() {
    scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL);
    if (ctx == NULL) {
        perror("seccomp_init");
        exit(EXIT_FLURE);
    }

    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);

    if (seccomp_load(ctx) < 0) {
        perror("seccomp_load");
        exit(EXIT_FLURE);
    }

    printf("Hello, World!\n");
    seccomp_release(ctx);
    return 0;
}

11.3 `AppArmor`

AppArmor是一个Linux安全模块，用于限制进程的权限。

aa-genprof /path/to/myscript
aa-enforce /path/to/myscript

11.4 `SELinux`

SELinux是一个Linux安全模块，用于强制访问控制。

semanage fcontext -a -t myscript_exec_t /path/to/myscript
restorecon /path/to/myscript

12. 进程调试和分析

12.1 `gcore`

gcore命令用于生成进程的核心转储文件。

gcore PID

12.2 `pstack`

pstack命令用于显示进程的堆栈跟踪。

pstack PID

12.3 `pmap`

pmap命令用于显示进程的内存映射。

pmap PID

12.4 `lsof`

lsof命令用于列出进程打开的文件。

lsof -p PID

13. 进程调试和分析

13.1 `strace`

strace命令用于跟踪进程的系统调用和信号。

strace ./myscript.sh

13.2 `ltrace`

ltrace命令用于跟踪进程的库函数调用。

ltrace ./myscript.sh

13.3 `gdb`

gdb是一个强大的调试工具，可以用于调试和分析进程。

gdb ./myscript

13.4 `valgrind`

valgrind是一个内存调试和分析工具，可以用于检测内存泄漏和其他内存问题。

valgrind ./myscript

14. 进程资源限制

14.1 `ulimit`

ulimit命令用于设置和显示进程的资源限制。

ulimit -a
ulimit -n 1024

14.2 `cgroups`

cgroups（控制组）是Linux内核功能，用于限制、记录和隔离进程组的资源使用。

”`bash cgcreate -g cpu:/mygroup cgset -r cpu.shares=512 mygroup cgex

linux创建进程的命令有哪些

Linux创建进程的命令有哪些

1. 命令行工具

1.1 fork() 和 exec() 系统调用

1.2 bash 和 sh 命令

1.3 nohup 命令

1.4 disown 命令

1.5 screen 和 tmux 命令

1.6 at 和 cron 命令

2. 系统调用

2.1 fork()

2.2 exec()

2.3 clone()

2.4 vfork()

3. 脚本语言中的相关命令

3.1 Python

3.2 Perl

3.3 Ruby

4. 其他工具和命令

4.1 systemd

4.2 init

4.3 upstart

4.4 docker

5. 进程管理命令

5.1 ps

5.2 top

5.3 htop

5.4 kill

5.5 pkill

5.6 killall

6. 进程间通信

6.1 管道（Pipe）

6.2 命名管道（Named Pipe）

6.3 信号（Signal）

6.4 共享内存（Shared Memory）

6.5 消息队列（Message Queue）

6.6 信号量（Semaphore）

7. 进程调度

7.1 nice 和 renice

7.2 chrt

7.3 taskset

8. 进程监控

8.1 strace

8.2 ltrace

8.3 gdb

8.4 valgrind