linux进程退出,删除消息队列

当 Linux 进程退出时，它所创建的消息队列不会自动删除。这意味着如果其他进程仍然使用该消息队列，它将继续存在。如果您希望在进程退出时删除消息队列，可以使用 IPC_RMID 命令将其标记为删除。这将使该消息队列在所有进程都不再使用它时自动删除。要使用 IPC_RMID 命令，请调用 msgctl() 函数并将 cmd 参数设置为 IPC_RMID。示例如下：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int main() {
    int msgid = msgget(IPC_PRIVATE, 0644); // 创建消息队列
    // 使用消息队列
    // ...
    msgctl(msgid, IPC_RMID, NULL); // 标记消息队列删除
    return 0;
}

注意，IPC_RMID 命令不会立即删除消息队列，而是将其标记为删除。实际删除将在所有使用该消息队列的进程都停止使用它后发生。

相关问题

linux c消息队列msgsnd多进程发送

在 Linux C 中使用消息队列进行进程间通信是一种常见的方式。使用 `msgsnd` 函数可以向消息队列中发送消息。下面是一个多进程发送消息到消息队列的示例代码：

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

#define MSG_SIZE 1024

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

int main() {
    key_t key;
    int msgid;
    char *msg = "Hello, world!";
    struct msgbuf buf;

    // 创建消息队列
    key = ftok(".", 'a');
    msgid = msgget(key, IPC_CREAT | 0666);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    // 发送消息
    for (int i = 0; i < 3; ++i) {
        buf.mtype = i + 1;
        strncpy(buf.mtext, msg, MSG_SIZE);
        if (msgsnd(msgid, &buf, strlen(buf.mtext) + 1, 0) == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }
        printf("Sent message '%s' to queue with type %ld\n", buf.mtext, buf.mtype);
    }

    return 0;
}

在这个示例中，我们首先使用 `ftok` 函数创建一个用于生成消息队列的 key。然后使用 `msgget` 函数创建一个消息队列，如果创建失败则输出错误信息并退出程序。

接下来，我们使用 `msgsnd` 函数向消息队列中发送消息。`msgsnd` 函数接收三个参数：消息队列 ID、消息指针和消息长度。在这里，我们将消息类型设置为 `i+1`，并将消息内容设置为 "Hello, world!"。发送完毕后，输出成功发送的消息内容和消息类型。

在实际应用中，我们可以使用 `fork` 函数创建多个进程，每个进程都可以通过 `msgsnd` 向消息队列发送消息。同时，我们也可以使用 `msgrcv` 函数从消息队列中接收消息。

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;
}

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