为什么linux多进程代码中有很多while(1)

在Linux多进程代码中，经常会使用while(1)循环来保持进程的运行。这是因为多进程程序中，每个进程都是独立运行的，如果不使用while(1)循环，进程在执行完一次任务后就会退出，这样就无法保持进程的持续运行。因此，使用while(1)可以让进程不断地执行任务，保持进程的持续运行。同时，在while(1)循环中可以使用一些条件语句和休眠函数来控制进程的执行，达到更加灵活的控制效果。

相关问题

在Linux中打印进程树的完整代码

以下是在Linux中打印进程树的完整代码：

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

#define MAX_PID_LEN 10
#define MAX_PATH_LEN 100

void print_tree(char *pid, int level);

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s <pid>\n", argv[0]);
        return -1;
    }

    print_tree(argv[1], 0);

    return 0;
}

void print_tree(char *pid, int level) {
    DIR *dir;
    struct dirent *entry;
    char path[MAX_PATH_LEN];
    char new_pid[MAX_PID_LEN];
    struct stat statbuf;
    int i;

    if (level == 0) {
        printf("%s\n", pid);
    }

    sprintf(path, "/proc/%s/task", pid);
    if ((dir = opendir(path)) == NULL) {
        return;
    }

    while ((entry = readdir(dir)) != NULL) {
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
            continue;
        }

        sprintf(path, "/proc/%s/task/%s", pid, entry->d_name);
        if (lstat(path, &statbuf) < 0) {
            continue;
        }

        if (S_ISDIR(statbuf.st_mode)) {
            for (i = 0; i < level + 1; i++) {
                printf("|   ");
            }

            printf("|-- ");
            printf("%s\n", entry->d_name);

            strncpy(new_pid, entry->d_name, MAX_PID_LEN);
            print_tree(new_pid, level + 1);
        }
    }

    closedir(dir);
}

该程序的主要思路是通过读取 `/proc` 目录下的进程信息来构建进程树。首先，程序接受一个进程 PID 作为命令行参数，并将其作为根节点打印出来。然后，程序遍历 `/proc/<pid>/task` 目录下的所有子目录，如果子目录是以数字命名的目录，就将其作为一个子节点打印出来，并递归打印其子节点。在打印子节点时，程序会在前面加上一些空格，以形成树状结构。

需要注意的是，程序中使用了 `lstat()` 函数来获取文件的元数据。这是因为 `/proc` 目录下的很多文件都是符号链接，如果直接使用 `stat()` 函数获取文件信息，会返回符号链接本身的信息，而不是链接指向的文件的信息。

Linux多人聊天室 消息队列和共享内存的代码

实现一个 Linux 多人聊天室，可以使用消息队列和共享内存来实现消息的传递和存储，以下是示例代码：

1. 服务器端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <unistd.h>
#include <signal.h>

#define MAX_CLIENTS 10
#define MAX_MSG_SIZE 1024
#define SERVER_MSG_TYPE 1
#define CLIENT_MSG_TYPE 2

// 客户端信息结构体
typedef struct {
    pid_t pid;
    char nickname[20];
    int msg_queue_id;
} client_info_t;

// 服务器消息结构体
typedef struct {
    long type;
    char msg[MAX_MSG_SIZE];
} server_msg_t;

// 客户端消息结构体
typedef struct {
    long type;
    char nickname[20];
    char msg[MAX_MSG_SIZE];
} client_msg_t;

int msg_queue_id; // 消息队列ID
int shm_id; // 共享内存ID
client_info_t* clients; // 客户端信息数组
int num_clients = 0; // 当前客户端数量

// 信号处理函数
void signal_handler(int sig) {
    if (sig == SIGINT) {
        // 删除消息队列和共享内存
        msgctl(msg_queue_id, IPC_RMID, NULL);
        shmctl(shm_id, IPC_RMID, NULL);
        exit(0);
    }
}

// 广播消息
void broadcast(char* nickname, char* msg) {
    int i;
    client_msg_t client_msg;
    server_msg_t server_msg;
    // 将消息发送给每个客户端
    for (i = 0; i < num_clients; i++) {
        if (clients[i].pid == 0) {
            continue;
        }
        // 将消息发送到客户端的消息队列中
        client_msg.type = CLIENT_MSG_TYPE;
        strcpy(client_msg.nickname, nickname);
        strcpy(client_msg.msg, msg);
        msgsnd(clients[i].msg_queue_id, &client_msg, sizeof(client_msg_t) - sizeof(long), 0);
    }
    // 将消息发送到服务器的消息队列中，以便记录聊天记录
    server_msg.type = SERVER_MSG_TYPE;
    sprintf(server_msg.msg, "[%s] %s", nickname, msg);
    msgsnd(msg_queue_id, &server_msg, sizeof(server_msg_t) - sizeof(long), 0);
}

int main() {
    int i;
    pid_t pid;
    client_msg_t client_msg;
    server_msg_t server_msg;
    // 注册信号处理函数
    signal(SIGINT, signal_handler);
    // 创建消息队列
    msg_queue_id = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
    if (msg_queue_id == -1) {
        perror("msgget");
        exit(1);
    }
    // 创建共享内存
    shm_id = shmget(IPC_PRIVATE, sizeof(client_info_t) * MAX_CLIENTS, 0666 | IPC_CREAT);
    if (shm_id == -1) {
        perror("shmget");
        exit(1);
    }
    clients = (client_info_t*) shmat(shm_id, NULL, 0);
    if (clients == (void*) -1) {
        perror("shmat");
        exit(1);
    }
    // 初始化客户端信息数组
    for (i = 0; i < MAX_CLIENTS; i++) {
        clients[i].pid = 0;
        clients[i].msg_queue_id = 0;
        strcpy(clients[i].nickname, "");
    }
    while (1) {
        // 接收客户端消息
        if (msgrcv(msg_queue_id, &client_msg, sizeof(client_msg_t) - sizeof(long), CLIENT_MSG_TYPE, 0) == -1) {
            perror("msgrcv");
            continue;
        }
        // 处理客户端消息
        if (strcmp(client_msg.msg, "/exit") == 0) {
            // 客户端退出
            for (i = 0; i < num_clients; i++) {
                if (strcmp(clients[i].nickname, client_msg.nickname) == 0) {
                    clients[i].pid = 0;
                    clients[i].msg_queue_id = 0;
                    strcpy(clients[i].nickname, "");
                    num_clients--;
                    break;
                }
            }
            printf("[Server] User %s left the chat room.\n", client_msg.nickname);
            broadcast("Server", client_msg.msg);
        } else if (client_msg.msg[0] == '/') {
            // 处理客户端命令
            char* cmd = strtok(client_msg.msg, " ");
            if (strcmp(cmd, "/list") == 0) {
                // 显示在线用户列表
                printf("[Server] Online users:\n");
                for (i = 0; i < num_clients; i++) {
                    if (clients[i].pid != 0) {
                        printf("[Server] %s\n", clients[i].nickname);
                    }
                }
            } else {
                // 未知命令
                server_msg.type = SERVER_MSG_TYPE;
                sprintf(server_msg.msg, "[Server] Unknown command: %s", cmd);
                msgsnd(client_msg.msg_queue_id, &server_msg, sizeof(server_msg_t) - sizeof(long), 0);
            }
        } else {
            // 广播消息
            broadcast(client_msg.nickname, client_msg.msg);
        }
        // 处理退出的客户端进程
        for (i = 0; i < num_clients; i++) {
            if (clients[i].pid != 0 && kill(clients[i].pid, 0) == -1) {
                clients[i].pid = 0;
                clients[i].msg_queue_id = 0;
                strcpy(clients[i].nickname, "");
                num_clients--;
                printf("[Server] User %d disconnected.\n", i);
                broadcast("Server", "User disconnected.");
            }
        }
        // 接受新的客户端连接
        if (num_clients < MAX_CLIENTS) {
            if (msgrcv(msg_queue_id, &client_msg, sizeof(client_msg_t) - sizeof(long), CLIENT_MSG_TYPE, IPC_NOWAIT) != -1) {
                if (strcmp(client_msg.msg, "/join") == 0) {
                    // 客户端连接
                    for (i = 0; i < MAX_CLIENTS; i++) {
                        if (clients[i].pid == 0) {
                            pid = fork();
                            if (pid == -1) {
                                perror("fork");
                            } else if (pid == 0) {
                                // 子进程处理客户端连接
                                execl("./client", "client", NULL);
                                perror("execl");
                                exit(1);
                            } else {
                                // 父进程保存客户端信息
                                clients[i].pid = pid;
                                clients[i].msg_queue_id = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
                                if (clients[i].msg_queue_id == -1) {
                                    perror("msgget");
                                    exit(1);
                                }
                                strcpy(clients[i].nickname, client_msg.nickname);
                                num_clients++;
                                printf("[Server] User %s joined the chat room.\n", client_msg.nickname);
                                broadcast("Server", "User joined the chat room.");
                                client_msg.type = CLIENT_MSG_TYPE;
                                sprintf(client_msg.msg, "Welcome to the chat room, %s!", client_msg.nickname);
                                msgsnd(clients[i].msg_queue_id, &client_msg, sizeof(client_msg_t) - sizeof(long), 0);
                                break;
                            }
                        }
                    }
                }
            }
        }
    }
    return 0;
}

2. 客户端代码：

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

#define MAX_MSG_SIZE 1024
#define SERVER_MSG_TYPE 1
#define CLIENT_MSG_TYPE 2

// 服务器消息结构体
typedef struct {
    long type;
    char msg[MAX_MSG_SIZE];
} server_msg_t;

// 客户端消息结构体
typedef struct {
    long type;
    char nickname[20];
    char msg[MAX_MSG_SIZE];
} client_msg_t;

int msg_queue_id; // 消息队列ID
char nickname[20]; // 用户昵称

// 信号处理函数
void signal_handler(int sig) {
    if (sig == SIGINT) {
        // 发送退出消息
        client_msg_t client_msg;
        client_msg.type = CLIENT_MSG_TYPE;
        strcpy(client_msg.nickname, nickname);
        strcpy(client_msg.msg, "/exit");
        msgsnd(msg_queue_id, &client_msg, sizeof(client_msg_t) - sizeof(long), 0);
        exit(0);
    }
}

int main() {
    int i;
    pid_t pid;
    client_msg_t client_msg;
    server_msg_t server_msg;
    // 注册信号处理函数
    signal(SIGINT, signal_handler);
    // 创建消息队列
    msg_queue_id = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
    if (msg_queue_id == -1) {
        perror("msgget");
        exit(1);
    }
    // 向服务器发送连接请求
    client_msg.type = CLIENT_MSG_TYPE;
    printf("Please input your nickname: ");
    scanf("%s", nickname);
    strcpy(client_msg.nickname, nickname);
    strcpy(client_msg.msg, "/join");
    msgsnd(msg_queue_id, &client_msg, sizeof(client_msg_t) - sizeof(long), 0);
    // 接收服务器消息
    while (1) {
        if (msgrcv(msg_queue_id, &server_msg, sizeof(server_msg_t) - sizeof(long), SERVER_MSG_TYPE, 0) == -1) {
            perror("msgrcv");
            continue;
        }
        printf("%s\n", server_msg.msg);
    }
    return 0;
}

以上代码只是一个简单的示例，实际上还有很多细节需要考虑，比如如何避免重名、如何处理客户端连接异常等。