【嵌入式Linux应用开发基础】进程实战开发

# 查看系统中所有进程
ps aux

# 实时监控进程资源占用
top

# 跟踪进程的系统调用
strace -p <PID>

# 终止进程
kill -9 <PID>

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

int main() {
    pid_t pid;

    // 创建子进程
    pid = fork();

    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程代码
        printf("This is the child process. PID: %d\n", getpid());
        exit(EXIT_SUCCESS);
    } else {
        // 父进程代码
        printf("This is the parent process. Child PID: %d\n", pid);
    }

    return 0;
}

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

int main() {
    pid_t pid;
    int status;

    pid = fork();

    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process is exiting with status 42\n");
        exit(42);
    } else {
        // 父进程等待子进程结束
        wait(&status);

        if (WIFEXITED(status)) {
            printf("Parent process: Child exited with status %d\n", WEXITSTATUS(status));
        }
    }

    return 0;
}

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

#define BUFFER_SIZE 1024

int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[BUFFER_SIZE];

    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe failed");
        exit(EXIT_FAILURE);
    }

    pid = fork();

    if (pid < 0) {
        perror("fork failed");
        close(pipefd[0]);
        close(pipefd[1]);
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程关闭读端
        close(pipefd[0]);

        // 向管道写入数据
        const char *message = "Hello from child process";
        write(pipefd[1], message, strlen(message));

        // 关闭写端
        close(pipefd[1]);
    } else {
        // 父进程关闭写端
        close(pipefd[1]);

        // 从管道读取数据
        ssize_t bytes_read = read(pipefd[0], buffer, sizeof(buffer) - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("Parent process received: %s\n", buffer);
        }

        // 关闭读端
        close(pipefd[0]);
    }

    return 0;
}

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

#define FIFO_NAME "my_fifo"
#define BUFFER_SIZE 1024

int main() {
    int fd;
    char buffer[BUFFER_SIZE];

    // 创建命名管道
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        perror("mkfifo failed");
        exit(EXIT_FAILURE);
    }

    // 打开命名管道进行读取
    fd = open(FIFO_NAME, O_RDONLY);
    if (fd == -1) {
        perror("open failed");
        unlink(FIFO_NAME);
        exit(EXIT_FAILURE);
    }

    // 从命名管道读取数据
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        printf("Received: %s\n", buffer);
    }

    // 关闭文件描述符并删除命名管道
    close(fd);
    unlink(FIFO_NAME);

    return 0;
}

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

void signal_handler(int signum) {
    printf("Received signal %d. Exiting...\n", signum);
    exit(EXIT_SUCCESS);
}

int main() {
    // 注册信号处理函数
    if (signal(SIGINT, signal_handler) == SIG_ERR) {
        perror("signal registration failed");
        exit(EXIT_FAILURE);
    }

    printf("Press Ctrl + C to send SIGINT signal...\n");

    while (1) {
        sleep(1);
    }

    return 0;
}

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

#define MONITORED_PROGRAM "./target_program"

void restart_monitored_process() {
    pid_t pid = fork();

    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程执行被监控的程序
        execl(MONITORED_PROGRAM, MONITORED_PROGRAM, NULL);
        perror("execl failed");
        exit(EXIT_FAILURE);
    }
}

void signal_handler(int signum) {
    if (signum == SIGCHLD) {
        int status;
        pid_t pid;

        // 等待子进程结束
        while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
            if (WIFEXITED(status)) {
                printf("Monitored process exited with status %d. Restarting...\n", WEXITSTATUS(status));
                restart_monitored_process();
            }
        }
    }
}

int main() {
    // 启动被监控的进程
    restart_monitored_process();

    // 注册信号处理函数
    if (signal(SIGCHLD, signal_handler) == SIG_ERR) {
        perror("signal registration failed");
        exit(EXIT_FAILURE);
    }

    while (1) {
        sleep(1);
    }

    return 0;
}