Message Queues - Learning Module

Loading content...

0/240

Priority Ordering

Urgency in Inter-Process Communication

Not all messages are created equal. In real systems, some messages require immediate attention while others can wait. A system alert about imminent disk failure must take precedence over a routine log message. A user login request should be processed before a background cleanup task.

Priority ordering in message queues allows processes to assign urgency levels to messages, ensuring critical communications are processed first. This capability is essential for building responsive, real-time, and deadline-aware systems.

Both System V and POSIX message queues support priority, but with fundamentally different mechanisms:

System V: Priority is implicit through message types—using negative msgtyp in receive selects lowest types first
POSIX: Priority is explicit per-message—higher priority values are dequeued first

Understanding these mechanisms and their trade-offs is crucial for designing systems that handle urgency correctly.

What You Will Master

By the end of this page, you will understand priority semantics in both System V and POSIX queues, how to implement priority-based task distribution, priority inversion problems and solutions, fair scheduling with priorities, and real-world priority queue patterns.

Priority in POSIX Message Queues

POSIX message queues provide native, per-message priority support. Each message sent with mq_send() has an associated priority, and mq_receive() always returns the highest-priority message first.

Priority Semantics

int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
            unsigned int msg_prio);

ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len,
                   unsigned int *msg_prio);

Key Properties:

Priority range: 0 to MQ_PRIO_MAX - 1 (typically 0-32767)
Higher value = higher priority: Priority 100 > Priority 10
FIFO within priority: Same-priority messages are ordered by arrival time
Automatic ordering: No selection needed—highest priority is always returned
Priority is preserved: The received message includes its original priority

System Limit Discovery

#include <unistd.h>

long max_prio = sysconf(_SC_MQ_PRIO_MAX);
printf("Maximum priority: %ld
", max_prio - 1);

posix_priority.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#include <fcntl.h>
#include <unistd.h>
 
#define QUEUE_NAME "/priority_demo"
#define MAX_MSG_SIZE 128
 
int main() {
    // Check system priority limit
    long max_prio = sysconf(_SC_MQ_PRIO_MAX);
    printf("System MQ_PRIO_MAX: %ld
", max_prio);
    printf("Usable priority range: 0 to %ld
 
", max_prio - 1);
    
    struct mq_attr attr = {
        .mq_maxmsg = 10,
        .mq_msgsize = MAX_MSG_SIZE
    };
    
    mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_RDWR, 0644, &attr);
    if (mq == (mqd_t)-1) {
        perror("mq_open");
        return EXIT_FAILURE;
    }
    
    // ========================================
    // Send messages in non-priority order
    // ========================================
    printf("=== Sending Messages (various priorities) ===
");
    
    struct { const char *msg; unsigned int prio; } messages[] = {
        {"Low priority task", 1},
        {"Normal priority task", 5},
        {"HIGH PRIORITY ALERT", 20},
        {"Another low priority", 1},
        {"Medium priority job", 10},
        {"CRITICAL SYSTEM ERROR", 31},
        {"Normal work", 5},
    };
    
    for (size_t i = 0; i < sizeof(messages)/sizeof(messages[0]); i++) {
        mq_send(mq, messages[i].msg, strlen(messages[i].msg), 
                messages[i].prio);
        printf("Sent (prio=%2u): %s
", messages[i].prio, messages[i].msg);
    }
    
    // ========================================
    // Receive messages (automatic priority order)
    // ========================================
    printf("
=== Receiving Messages (priority order) ===
");
    
    char buffer[MAX_MSG_SIZE];
    unsigned int priority;
    ssize_t len;
    int count = 1;
    
    while ((len = mq_receive(mq, buffer, MAX_MSG_SIZE, &priority)) > 0) {
        buffer[len] = '\0';
        printf("%d. (prio=%2u) %s
", count++, priority, buffer);
    }
    
    printf("
Notice: Messages received in priority order, FIFO within same priority
");
    
    mq_close(mq);
    mq_unlink(QUEUE_NAME);
    
    return EXIT_SUCCESS;
}

Priority Order Guarantee

POSIX guarantees that mq_receive() returns the oldest message with the highest priority. You cannot receive a lower-priority message while higher-priority messages exist—even if you want to. For selective reception, you need System V queues or multiple POSIX queues.

Priority via System V Message Types

System V message queues don't have explicit priority. Instead, priority behavior is achieved through the mtype field and negative msgtyp in msgrcv().

The Negative msgtyp Technique

Recall that msgrcv(msqid, &msg, size, msgtyp, flags) with:

msgtyp > 0: Receives first message with that exact type
msgtyp < 0: Receives first message with type ≤ |msgtyp|, lowest type first

This "lowest type first" behavior creates priority ordering:

// Define priorities (lower number = higher priority)
#define PRIO_CRITICAL  1L   // Highest priority
#define PRIO_HIGH      10L
#define PRIO_NORMAL    100L
#define PRIO_LOW       1000L

// Receive highest-priority message (lowest type)
msgrcv(msqid, &msg, size, -1000L, 0);  // Gets type 1 first

Key Differences from POSIX

Aspect	System V	POSIX
Priority direction	Lower mtype = higher priority	Higher priority = higher priority
Selectivity	Can still select specific types	Always highest priority first
Dual use	mtype serves as type AND priority	Separate priority field
Range	Positive long (1 to LONG_MAX)	0 to MQ_PRIO_MAX-1

sysv_priority.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
 
// Priority levels (lower = higher priority)
#define PRIO_CRITICAL  1L
#define PRIO_HIGH      10L
#define PRIO_NORMAL    100L
#define PRIO_LOW       1000L
#define PRIO_BACKGROUND 10000L
 
// Maximum priority level for reception
#define PRIO_MAX       PRIO_BACKGROUND
 
struct priority_msg {
    long mtype;   // Used as priority (lower = more urgent)
    char text[128];
};
 
const char* priority_name(long prio) {
    if (prio <= PRIO_CRITICAL) return "CRITICAL";
    if (prio <= PRIO_HIGH) return "HIGH";
    if (prio <= PRIO_NORMAL) return "NORMAL";
    if (prio <= PRIO_LOW) return "LOW";
    return "BACKGROUND";
}
 
int main() {
    int msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0666);
    if (msqid == -1) {
        perror("msgget");
        return EXIT_FAILURE;
    }
    
    struct priority_msg msg;
    
    // ========================================
    // Send messages with various priorities
    // ========================================
    printf("=== Sending Messages ===
");
    
    struct { long prio; const char *text; } messages[] = {
        {PRIO_NORMAL, "Normal task 1"},
        {PRIO_LOW, "Low priority cleanup"},
        {PRIO_CRITICAL, "SYSTEM CRITICAL ALERT!"},
        {PRIO_NORMAL, "Normal task 2"},
        {PRIO_HIGH, "High priority request"},
        {PRIO_BACKGROUND, "Background indexing"},
        {PRIO_CRITICAL, "Another critical issue"},
    };
    
    for (size_t i = 0; i < sizeof(messages)/sizeof(messages[0]); i++) {
        msg.mtype = messages[i].prio;
        strncpy(msg.text, messages[i].text, sizeof(msg.text));
        msgsnd(msqid, &msg, sizeof(msg.text), 0);
        printf("Sent (%s): %s
", 
               priority_name(messages[i].prio), messages[i].text);
    }
    
    // ========================================
    // Receive in priority order using negative msgtyp
    // ========================================
    printf("
=== Receiving in Priority Order ===
");
    printf("Using msgtyp = -%ld (receives lowest type first)
 
", PRIO_MAX);
    
    int count = 1;
    while (msgrcv(msqid, &msg, sizeof(msg.text), 
                  -PRIO_MAX, IPC_NOWAIT) != -1) {
        printf("%d. [%10s] %s
", 
               count++, priority_name(msg.mtype), msg.text);
    }
    
    printf("
=== Analysis ===
");
    printf("Notice: CRITICAL messages (mtype=1) received first,
");
    printf("then HIGH (10), NORMAL (100), LOW (1000), BACKGROUND (10000).
");
    printf("Within same priority level, FIFO order is preserved.
");
    
    msgctl(msqid, IPC_RMID, NULL);
    return EXIT_SUCCESS;
}

Choosing Priority Levels

Leave gaps between priority levels (1, 10, 100, 1000) to allow inserting new levels later. If you use contiguous values (1, 2, 3, 4), you can't easily add a priority between CRITICAL and HIGH without renumbering everything.

Priority-Based Task Distribution

One of the most common uses for priority message queues is task distribution to worker processes. Tasks are submitted with priorities, and workers always pick up the most urgent work first.

Task Queue Architecture

[Producer] ─┬─ Priority 31 ──┐
[Producer] ─┼─ Priority 10  ─┼─► [Priority Queue] ─┬─► [Worker 1]
[Producer] ─┼─ Priority 5   ─┤                    ├─► [Worker 2]
[Producer] ─┴─ Priority 1   ─┘                    └─► [Worker 3]
                                       ▲ Workers compete for
                                         highest priority task

Key Design Decisions

Priority assignment: Who decides task priority? Producer? Central scheduler?
Starvation prevention: Can low-priority tasks starve forever?
Load balancing: How to spread work across workers fairly?
Priority aging: Should waiting tasks' priority increase over time?

priority_worker_pool.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <mqueue.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <time.h>
 
#define QUEUE_NAME "/task_queue"
#define MAX_MSG_SIZE 256
#define NUM_WORKERS 3
#define TASKS_PER_PRODUCER 5
 
// Task message structure
struct task {
    int task_id;
    int complexity;  // 1-10, affects processing time
    char description[200];
};
 
// Worker process
void worker(int worker_id) {
    mqd_t mq = mq_open(QUEUE_NAME, O_RDONLY);
    if (mq == (mqd_t)-1) {
        perror("worker mq_open");
        exit(1);
    }
    
    struct mq_attr attr;
    mq_getattr(mq, &attr);
    
    struct task task;
    unsigned int priority;
    
    printf("[Worker %d] Started
", worker_id);
    
    while (1) {
        ssize_t len = mq_receive(mq, (char*)&task, attr.mq_msgsize, &priority);
        if (len == -1) break;
        
        printf("[Worker %d] Processing task %d (priority=%u, complexity=%d): %s
",
               worker_id, task.task_id, priority, task.complexity, 
               task.description);
        
        // Simulate work based on complexity
        usleep(task.complexity * 50000);  // 50-500ms
        
        printf("[Worker %d] Completed task %d
", worker_id, task.task_id);
        
        // Exit condition: special shutdown task
        if (priority == 0 && task.task_id == -1) {
            break;
        }
    }
    
    mq_close(mq);
    printf("[Worker %d] Shutting down
", worker_id);
}
 
// Producer process
void producer(mqd_t mq, int producer_id, int start_task_id) {
    srand(time(NULL) + producer_id);
    
    struct task task;
    
    for (int i = 0; i < TASKS_PER_PRODUCER; i++) {
        task.task_id = start_task_id + i;
        task.complexity = (rand() % 10) + 1;
        
        // Assign random priority (higher = more urgent)
        unsigned int priority = (rand() % 30) + 1;
        
        snprintf(task.description, sizeof(task.description),
                 "Task from producer %d", producer_id);
        
        mq_send(mq, (char*)&task, sizeof(task), priority);
        printf("[Producer %d] Submitted task %d with priority %u
",
               producer_id, task.task_id, priority);
        
        usleep(10000);  // Small delay between submissions
    }
}
 
int main() {
    // Create queue
    struct mq_attr attr = {
        .mq_maxmsg = 50,
        .mq_msgsize = MAX_MSG_SIZE
    };
    
    mq_unlink(QUEUE_NAME);  // Clean up any existing queue
    mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_RDWR, 0644, &attr);
    if (mq == (mqd_t)-1) {
        perror("mq_open");
        return EXIT_FAILURE;
    }
    
    printf("=== Priority Task Distribution Demo ===
 
");
    
    // Start workers
    pid_t worker_pids[NUM_WORKERS];
    for (int i = 0; i < NUM_WORKERS; i++) {
        worker_pids[i] = fork();
        if (worker_pids[i] == 0) {
            worker(i + 1);
            exit(0);
        }
    }
    
    sleep(1);  // Let workers start
    
    // Run producers (in main process for simplicity)
    printf("
=== Submitting Tasks ===
");
    producer(mq, 1, 1);
    producer(mq, 2, 100);
    
    // Wait for queue to drain
    sleep(3);
    
    // Send shutdown signals
    struct task shutdown = { .task_id = -1 };
    for (int i = 0; i < NUM_WORKERS; i++) {
        mq_send(mq, (char*)&shutdown, sizeof(shutdown), 0);
    }
    
    // Wait for workers
    for (int i = 0; i < NUM_WORKERS; i++) {
        waitpid(worker_pids[i], NULL, 0);
    }
    
    printf("
=== All workers completed ===
");
    
    mq_close(mq);
    mq_unlink(QUEUE_NAME);
    return EXIT_SUCCESS;
}

Priority Inversion Problem

Priority inversion occurs when a high-priority task is blocked waiting for a resource held by a low-priority task, while medium-priority tasks run freely. This violates the fundamental expectation that higher-priority work completes first.

Classic Priority Inversion Scenario

Time →

Process L (Low priority):    [====HOLDS LOCK====]────waiting─────►
Process M (Med priority):         [=====RUNNING FREELY=====]
Process H (High priority):              [WAITING FOR LOCK...]──►

                                          ↑
                            H should run, but M runs instead!
                            H is blocked by L, L can't release
                            lock because M is running.

Mars Pathfinder Incident (1997)

NASA's Mars Pathfinder mission experienced priority inversion that caused system resets. A low-priority meteorological task held a shared mutex while a high-priority bus management task waited. Medium-priority tasks continued running, and the high-priority task missed deadlines, triggering watchdog resets.

Priority Inversion in Message Queues

Message queues can experience analogous problems:

Queue full: High-priority producer can't send because low-priority messages fill the queue
Response waiting: High-priority client waits for response from overloaded low-priority server
Consumer starvation: Slow consumer processes low-priority messages while high-priority messages queue up

Mitigation Strategies

•Priority Inheritance — Temporarily boost low-priority holder to high-priority waiter's level. Standard in mutex implementations; not available in message queues.
•Priority Ceiling — Resources have a priority ceiling; any holder runs at that ceiling. Prevents inversions but can reduce concurrency.
•Separate Queues by Priority — Use distinct queues for different priority levels. High-priority queue never blocked by low-priority messages.
•Bounded Queue Capacity — Limit low-priority message accumulation. Reserve capacity for high-priority messages.
•Aging with Priority Boost — Increase priority of waiting messages over time. Prevents starvation but complicates priority semantics.

Design for Priority Inversion

Priority inversion is a design problem, not a runtime problem. If your system uses priorities, audit every shared resource, every queue, and every synchronization point for inversion potential. The bugs are subtle and often only manifest under specific load patterns.

Starvation Prevention and Fairness

In strict priority systems, low-priority messages can starve indefinitely if high-priority messages keep arriving. This is sometimes acceptable (critical alerts should always preempt logging), but often problematic.

The Starvation Problem

Time →

Arrivals:  H  H  L  H  H  L  H  H  L  H  H  L  ...
Processed: H  H     H  H     H  H     H  H  ...  (L never runs!)

Starvation Prevention Techniques

1. Priority Aging Increase message priority based on time waiting:

effective_priority = base_priority + (wait_time / aging_interval)

Caveat: Complicates priority semantics; all priorities eventually become "high."

2. Weighted Fair Queuing Process N high-priority messages, then 1 low-priority:

// Process 5 high-priority, then 1 low-priority
for (i = 0; i < 5; i++) {
    receive_high_priority();
}
receive_any_priority();

3. Quota Systems Limit high-priority message submission rate:

if (high_prio_this_second > QUOTA) {
    reject_or_downgrade(message);
}

4. Multi-Queue with Weighted Consumption Separate queues, weighted round-robin consumption.

fair_priority.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#include <fcntl.h>
#include <time.h>
#include <errno.h>
 
// ================================================
// Fair Priority Consumer with Weighted Processing
// ================================================
 
#define QUEUE_NAME "/fair_demo"
#define MAX_MSG_SIZE 128
 
// Priority tiers
#define TIER_HIGH    20   // Priority >= 20
#define TIER_NORMAL  10   // Priority 10-19
#define TIER_LOW     0    // Priority 0-9
 
// Weights: process high_weight high-priority, then normal_weight normal, etc.
#define WEIGHT_HIGH   5
#define WEIGHT_NORMAL 3
#define WEIGHT_LOW    1
 
struct message {
    int id;
    char content[120];
};
 
// Try to receive a message within a priority range
// Returns 1 if received, 0 if none available in range
int receive_in_range(mqd_t mq, struct message *msg, 
                     unsigned int *priority,
                     unsigned int min_prio, unsigned int max_prio) {
    
    struct mq_attr attr;
    mq_getattr(mq, &attr);
    
    // Try to receive (non-blocking)
    ssize_t len = mq_receive(mq, (char*)msg, attr.mq_msgsize, priority);
    
    if (len == -1) {
        return 0;  // Queue empty
    }
    
    // Check if priority is in our target range
    if (*priority >= min_prio && *priority <= max_prio) {
        return 1;  // Got one in range
    }
    
    // Wrong priority tier - put it back (imperfect but demonstrates concept)
    // In production, you'd use separate queues per tier
    mq_send(mq, (char*)msg, sizeof(*msg), *priority);
    return 0;
}
 
void fair_consumer(mqd_t mq) {
    struct message msg;
    unsigned int priority;
    int total = 0;
    int high_count = 0, normal_count = 0, low_count = 0;
    
    printf("=== Fair Priority Consumer ===
");
    printf("Weights: HIGH=%d, NORMAL=%d, LOW=%d
 
",
           WEIGHT_HIGH, WEIGHT_NORMAL, WEIGHT_LOW);
    
    // Process in weighted rounds
    while (total < 20) {
        int processed_this_round = 0;
        
        // Process WEIGHT_HIGH high-priority messages
        for (int i = 0; i < WEIGHT_HIGH; i++) {
            if (receive_in_range(mq, &msg, &priority, TIER_HIGH, 31)) {
                printf("HIGH   (prio=%2u): msg %d
", priority, msg.id);
                high_count++;
                total++;
                processed_this_round++;
            }
        }
        
        // Process WEIGHT_NORMAL normal-priority messages
        for (int i = 0; i < WEIGHT_NORMAL; i++) {
            if (receive_in_range(mq, &msg, &priority, TIER_NORMAL, TIER_HIGH-1)) {
                printf("NORMAL (prio=%2u): msg %d
", priority, msg.id);
                normal_count++;
                total++;
                processed_this_round++;
            }
        }
        
        // Process WEIGHT_LOW low-priority messages
        for (int i = 0; i < WEIGHT_LOW; i++) {
            if (receive_in_range(mq, &msg, &priority, TIER_LOW, TIER_NORMAL-1)) {
                printf("LOW    (prio=%2u): msg %d
", priority, msg.id);
                low_count++;
                total++;
                processed_this_round++;
            }
        }
        
        if (processed_this_round == 0) break;  // Queue drained
    }
    
    printf("
=== Summary ===
");
    printf("High: %d, Normal: %d, Low: %d
", high_count, normal_count, low_count);
    printf("Expected ratio: %d:%d:%d
", WEIGHT_HIGH, WEIGHT_NORMAL, WEIGHT_LOW);
}
 
int main() {
    struct mq_attr attr = { .mq_maxmsg = 50, .mq_msgsize = MAX_MSG_SIZE };
    
    mq_unlink(QUEUE_NAME);
    mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_RDWR, 0644, &attr);
    if (mq == (mqd_t)-1) {
        perror("mq_open");
        return EXIT_FAILURE;
    }
    
    // Populate queue with mixed priorities
    printf("Populating queue with mixed-priority messages...
 
");
    
    struct message msg;
    srand(time(NULL));
    
    for (int i = 1; i <= 30; i++) {
        msg.id = i;
        snprintf(msg.content, sizeof(msg.content), "Message %d", i);
        
        // Distribute priorities: more high than low (typical load)
        unsigned int prio;
        int r = rand() % 10;
        if (r < 5) prio = 20 + (rand() % 10);       // 50% high
        else if (r < 8) prio = 10 + (rand() % 10);   // 30% normal
        else prio = rand() % 10;                     // 20% low
        
        mq_send(mq, (char*)&msg, sizeof(msg), prio);
    }
    
    fair_consumer(mq);
    
    mq_close(mq);
    mq_unlink(QUEUE_NAME);
    return EXIT_SUCCESS;
}

Real-World Priority Patterns

Production systems use various priority patterns tailored to their requirements. Here are proven designs from real-world systems:

Priority Patterns in Production Systems
Pattern	Description	Use Case
Two-Queue	Separate queues: urgent + normal	Simple systems; clear urgent/non-urgent division
N-Tier Queues	One queue per priority tier (e.g., 3-5 queues)	Complex systems; prevents cross-tier interference
Deadline-Based	Priority derived from deadline proximity	Real-time systems; ETL pipelines with SLAs
Cost-Based	Priority based on message processing cost	Resource optimization; batch processing
Hybrid Type+Priority	System V types for routing, nested priority for ordering	Complex routing with per-route priorities

Priority Design Principles

•Fewer priority levels is better — 3-5 levels are usually sufficient. Too many levels create complexity without benefit.
•Document priority semantics — What does 'high priority' mean? Processing within 1 second? Before lower priorities? Be explicit.
•Monitor priority distribution — Track what fraction of messages are each priority. If 90% are 'high', you have priority inflation.
•Plan for priority abuse — Systems tend toward priority inflation. Build rate limits or quotas for high-priority submissions.
•Separate truly critical from merely urgent — Reserve highest priority for genuine emergencies (disk fail, security breach), not just 'important' work.
•Test with realistic priority distributions — If production is 60% high, 30% normal, 10% low, test with those ratios.

Priority Inflation

Like credential inflation in organizations, priority inflation is inevitable. Users and systems learn that high-priority gets faster service, so everything becomes high-priority. Combat this with quotas, auditing, or automatic priority decay for chronic high-priority senders.

Summary: Priority Ordering

We've explored priority ordering in message queues comprehensively. Here are the essential takeaways:

Key Takeaways

•POSIX has native priority — Per-message priority with higher values = higher priority. Always returns highest priority first.
•System V uses mtype for priority — Lower mtype values = higher priority when using negative msgtyp in receive.
•Priority inversion is real — High-priority work can be blocked by low-priority work. Design defensive systems.
•Starvation requires mitigation — Use aging, weighted queuing, or quotas to prevent low-priority starvation.
•Fewer priority levels are better — 3-5 levels are typically sufficient. More creates complexity without proportional benefit.
•Monitor and defend against priority inflation — Systems naturally drift toward everything being high-priority.

Page Complete

You now understand priority ordering in message queues—how to implement it, its pitfalls, and production patterns. Next, we'll explore the advantages of message queues and when they're the right choice for your IPC needs.