Despite POSIX’s advantages, System V message queues remain in use for several reasons:

• Legacy code — large C codebases written in the 1990s use System V IPC extensively. Porting carries risk and cost.
• Type-based selective receive — msgrcv() lets you receive only messages of a specific type (or the lowest type ≤ a threshold). POSIX only gives you the highest-priority message available; you cannot selectively receive by message category without extra logic.
• No extra library — System V IPC is built into the kernel with no link-time dependency. POSIX message queues require -lmqueue on Linux.
• Availability on older kernels — early embedded Linux kernels sometimes lacked POSIX message queue support.

The same task — create a queue and send one message — using both APIs:

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

int main(void)
{
    mqd_t mqd;
    struct mq_attr attr = {
        .mq_maxmsg  = 10,
        .mq_msgsize = 256
    };
    const char *msg = "hello";

    /* Create queue with a readable name */
    mq_unlink("/myq");
    mqd = mq_open("/myq",
                  O_CREAT | O_WRONLY,
                  0600, &attr);
    if (mqd == (mqd_t)-1) {
        perror("mq_open"); exit(1);
    }

    /* Send with priority 1 */
    if (mq_send(mqd, msg,
                strlen(msg), 1) == -1) {
        perror("mq_send"); exit(1);
    }

    printf("Sent: %s\n", msg);
    mq_close(mqd);
    mq_unlink("/myq");
    return 0;
}
/* Compile: gcc ... -lmqueue */

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

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

int main(void)
{
    key_t key;
    int msqid;
    struct msgbuf buf;

    /* Generate a key from a file path */
    key = ftok("/tmp/myq_key", 42);
    if (key == -1) {
        perror("ftok"); exit(1);
    }

    /* Create queue */
    msqid = msgget(key,
                   IPC_CREAT | 0600);
    if (msqid == -1) {
        perror("msgget"); exit(1);
    }

    buf.mtype = 1;
    strcpy(buf.mtext, "hello");

    /* Send */
    if (msgsnd(msqid, &buf,
               strlen(buf.mtext)+1,
               0) == -1) {
        perror("msgsnd"); exit(1);
    }

    printf("Sent: %s\n", buf.mtext);

    /* Delete immediately */
    msgctl(msqid, IPC_RMID, NULL);
    return 0;
}
/* Compile: gcc ... (no extra lib) */

This demonstrates that mq_unlink() does not destroy the queue while another process still has it open:

/* mq_refcount_demo.c */
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define QNAME "/refcount_test"

int main(void)
{
    struct mq_attr attr = { 0, 5, 64, 0 };
    mqd_t writer, reader;

    /* Create queue */
    mq_unlink(QNAME);
    writer = mq_open(QNAME, O_CREAT | O_WRONLY, 0600, &attr);
    reader = mq_open(QNAME, O_RDONLY, 0, NULL);

    if (writer == (mqd_t)-1 || reader == (mqd_t)-1) {
        perror("mq_open"); exit(1);
    }

    /* Unlink the name — queue still alive because reader/writer are open */
    mq_unlink(QNAME);
    printf("Unlinked '%s' — but queue is still alive (descriptors open)\n",
           QNAME);

    /* Send and receive still work! */
    mq_send(writer, "test", 4, 1);

    char buf[64];
    ssize_t n = mq_receive(reader, buf, 64, NULL);
    if (n > 0) printf("Received after unlink: %.*s\n", (int)n, buf);

    /* Now close both descriptors — queue is finally destroyed */
    mq_close(writer);
    mq_close(reader);
    printf("Both descriptors closed — queue memory released by kernel.\n");

    return 0;
}
/* With System V, msgctl(IPC_RMID) would destroy the queue
 * immediately, making the msgrcv call fail. */