Linux系统进程深入理解攻略

进程是Linux系统中的基本执行单元，它是操作系统分配资源和管理外部设备的衔接点。理解Linux系统进程的原理和机制对于进行系统调优、写高效程序以及诊断问题等方面非常重要。本文将系统全面介绍进程的相关知识点。

什么是进程？

进程表示正在运行的程序，是操作系统中最为重要的一个概念之一。在Linux中，每个进程都由进程号（PID）标识，并有自己的地址空间、资源占用、状态等信息。

如何查看进程？

在终端中，我们可以使用常见的shell命令"ps"和"top"来查看正在运行的进程和其相关信息。下面是一些常用命令：

查看所有进程：ps -ef
查看某个进程的详细信息：ps -p [PID]
实时查看进程信息：top

进程状态

在Linux中，进程有以下几种状态：

运行态（Running）：进程正在运行。
就绪态（Ready）：进程已经准备就绪，只需要等待系统调度。
等待态（Waiting）：进程正在等待资源或事件，例如等待I/O、等待信号等。
僵尸态（Zombie）：进程已经结束但是其进程描述符（PID）仍然存在，需要通过wait()或waitpid()来回收。

进程间通信（IPC）

Linux中的进程并不是完全独立的，它们可能需要相互通信来共享信息和协作。Linux系统提供了多种IPC机制，例如管道、共享内存、消息队列等。

下面是一个使用消息队列进行进程间通信的示例：

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

#define MAX_SIZE 1024

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

void send_msg(int msgid, char* msg)
{
    struct msgbuf msg_buf;
    msg_buf.mtype = 1;
    strcpy(msg_buf.mtext, msg);
    msgsnd(msgid, (void*)&msg_buf, MAX_SIZE, 0);
}

void recv_msg(int msgid)
{
    struct msgbuf msg_buf;
    msgrcv(msgid, (void*)&msg_buf, MAX_SIZE, 0, 0);
    printf("Received message: %s\n", msg_buf.mtext);
}

int main(int argc, char** argv)
{
    // 创建消息队列
    int msgid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(1);
    }

    // 创建子进程
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {
        // 子进程发送消息
        while (1) {
            send_msg(msgid, "Hello from child!");
            usleep(1000 * 1000);
        }
    } else {
        // 父进程接收消息
        while (1) {
            recv_msg(msgid);
        }
    }

    // 删除消息队列
    msgctl(msgid, IPC_RMID, NULL);
    return 0;
}

在这个示例中，我们使用了msgget、msgsnd、msgrcv和msgctl这些系统调用来创建消息队列、发送消息、接收消息、删除消息队列。

进程调度

Linux中有多种进程调度算法，例如时间片轮转、先来先服务（FCFS）、最高优先级优先等。这些算法有着各自的优缺点，可以根据具体应用场景选择相应的策略。

下面是一个使用时间片轮转调度算法的示例：

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

#define MAX_PROCESSES 10
#define MAX_TIME_SLICE 1000 // 时间片长度（ms）

int processes[MAX_PROCESSES]; // 进程数组
int n_processes = 0; // 进程数量
volatile int current_process = -1; // 当前运行的进程
int timer = 0; // 计时器

// 定时器处理函数
void handler(int signum)
{
    if (current_process != -1) {
        printf("Process %d: %dms\n", current_process, timer);

        // 增加计时器
        timer += MAX_TIME_SLICE;

        // 中断当前进程，添加到进程队尾
        processes[n_processes] = current_process;
        n_processes++;
    }

    // 按照时间片轮转调度
    if (n_processes > 0) {
        // 取出队首进程
        current_process = processes[0];

        // 后移其他进程
        for (int i = 1; i < n_processes; i++)
            processes[i - 1] = processes[i];

        // 减少进程数量
        n_processes--;

        // 重置计时器
        timer = 0;

        // 发送SIGCONT信号，继续执行
        kill(current_process, SIGCONT);
    } else {
        current_process = -1;
    }

    // 注册计时器
    signal(SIGALRM, handler);
    alarm(MAX_TIME_SLICE / 1000);
} 

// 进程函数
void process_function(int id)
{
    while (1) {
        printf("Process %d: running...\n", id);
        usleep(1000 * 500);
        kill(getpid(), SIGSTOP);
    }
}

int main(int argc, char** argv)
{
    // 创建进程
    for (int i = 0; i < MAX_PROCESSES; i++) {
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            exit(1);
        } else if (pid == 0) {
            // 子进程
            process_function(i);
        } else {
            // 父进程
            processes[n_processes] = pid;
            n_processes++;
        }
    }

    // 注册计时器
    signal(SIGALRM, handler);
    alarm(MAX_TIME_SLICE / 1000);

    // 等待子进程结束
    while (1) {
        pid_t pid = wait(NULL);
        if (pid == -1)
            break;
    }
    return 0;
}

在这个示例中，我们使用了计时器和信号来模拟时间片轮转的调度方式。