PhilKa am 21. Oktober 2025 um 14:03 Uhr

2025-10-21T14:03:01Z

← Nächstältere Version		Version vom 21. Oktober 2025, 16:03 Uhr
Zeile 1:		Zeile 1:
	= POSIX Message Queues =		= POSIX Message Queues =

	'''POSIX Message Queues''' (deutsch: POSIX-Nachrichtenwarteschlangen) sind ein Mechanismus zur Interprozesskommunikation (IPC), der es Prozessen erlaubt, Nachrichten über eine systemweite Warteschlange auszutauschen.		'''POSIX Message Queues''' (deutsch: POSIX-Nachrichtenwarteschlangen) sind ein Mechanismus zur ''Interprozesskommunikation (IPC)'', der es Prozessen erlaubt, ''Nachrichten über eine systemweite Warteschlange auszutauschen''.
	Sie sind in der POSIX-Norm (IEEE Std 1003.1b-1993) definiert und bieten eine modernere und leistungsfähigere Alternative zu den älteren System-V-Nachrichtenwarteschlangen.		Sie sind in der ''POSIX-Norm (IEEE Std 1003.1b-1993)'' definiert und bieten eine modernere und leistungsfähigere Alternative zu den älteren System-V-Nachrichtenwarteschlangen.

	---		---
Zeile 8:		Zeile 8:
	== Grundprinzip ==		== Grundprinzip ==
	Eine POSIX Message Queue (Nachrichtenwarteschlange) funktioniert ähnlich wie eine FIFO-Queue:		Eine POSIX Message Queue (Nachrichtenwarteschlange) funktioniert ähnlich wie eine FIFO-Queue:
	Prozesse können Nachrichten anhängen (senden) und entnehmen (empfangen).		Prozesse können Nachrichten ''anhängen (senden)'' und ''entnehmen (empfangen)''.
	Im Gegensatz zu klassischen Pipes oder Sockets werden hier strukturierte Nachrichten mit einer Priorität verwaltet.		Im Gegensatz zu klassischen Pipes oder Sockets werden hier ''strukturierte Nachrichten'' mit einer ''Priorität'' verwaltet.

	<pre>		<pre>
Zeile 21:		Zeile 21:
	</pre>		</pre>

	→ Nachrichten werden in der Reihenfolge ihrer Priorität (höchste zuerst) abgearbeitet.		→ Nachrichten werden in der Reihenfolge ihrer ''Priorität'' (höchste zuerst) abgearbeitet.

	---		---

PhilKa: Die Seite wurde neu angelegt: „= POSIX Message Queues = '''POSIX Message Queues''' (deutsch: POSIX-Nachrichtenwarteschlangen) sind ein Mechanismus zur Interprozesskommunikation (IPC), der es Prozessen erlaubt, Nachrichten über eine systemweite Warteschlange auszutauschen. Sie sind in der POSIX-Norm (IEEE Std 1003.1b-1993) definiert und bieten eine modernere und leistungsfähigere Alternative zu den älteren System-V-Nachrichtenwarteschlangen. --- == Grundprinzip ==…“

2025-10-21T14:01:33Z

Die Seite wurde neu angelegt: „= POSIX Message Queues = '''POSIX Message Queues''' (deutsch: *POSIX-Nachrichtenwarteschlangen*) sind ein Mechanismus zur **Interprozesskommunikation (IPC)**, der es Prozessen erlaubt, **Nachrichten über eine systemweite Warteschlange auszutauschen**. Sie sind in der **POSIX-Norm (IEEE Std 1003.1b-1993)** definiert und bieten eine modernere und leistungsfähigere Alternative zu den älteren System-V-Nachrichtenwarteschlangen. --- == Grundprinzip ==…“

Neue Seite

= POSIX Message Queues =

'''POSIX Message Queues''' (deutsch: *POSIX-Nachrichtenwarteschlangen*) sind ein Mechanismus zur **Interprozesskommunikation (IPC)**, der es Prozessen erlaubt, **Nachrichten über eine systemweite Warteschlange auszutauschen**.
Sie sind in der **POSIX-Norm (IEEE Std 1003.1b-1993)** definiert und bieten eine modernere und leistungsfähigere Alternative zu den älteren System-V-Nachrichtenwarteschlangen.

---

== Grundprinzip ==
Eine POSIX Message Queue (Nachrichtenwarteschlange) funktioniert ähnlich wie eine FIFO-Queue:
Prozesse können Nachrichten **anhängen (senden)** und **entnehmen (empfangen)**.
Im Gegensatz zu klassischen Pipes oder Sockets werden hier **strukturierte Nachrichten** mit einer **Priorität** verwaltet.

<pre>
+-------------------------+
| Warteschlange | (z. B. /myqueue)
|-------------------------|
| Priorität 10: "Start" |
| Priorität 5: "Ping" |
| Priorität 1: "Stop" |
+-------------------------+
</pre>

→ Nachrichten werden in der Reihenfolge ihrer **Priorität** (höchste zuerst) abgearbeitet.

---

== Eigenschaften ==
* Kommunikation zwischen beliebigen Prozessen über Namen (z. B. <code>/myqueue</code>)
* Nachrichtenbasierte Kommunikation (keine Bytestreams)
* Nachrichten enthalten Nutzdaten + Priorität
* Thread-sicher und asynchron nutzbar
* Optionale Benachrichtigung via Signal oder Thread

---

== Header-Dateien ==
<syntaxhighlight lang="c">
#include <mqueue.h>
#include <fcntl.h> // O_CREAT, O_RDWR
#include <sys/stat.h> // mode_t
</syntaxhighlight>

Beim Linken ist meist die Echtzeitbibliothek erforderlich:
<syntaxhighlight lang="bash">
gcc main.c -o main -lrt
</syntaxhighlight>

---

== Aufbau einer Message Queue ==
Eine POSIX Message Queue besitzt folgende Parameter:
{| class="wikitable"
! Attribut !! Beschreibung
|-
| Name || Beginnt immer mit <code>/</code> (z. B. <code>/demoqueue</code>)
|-
| Nachrichtenkapazität || Maximale Anzahl gespeicherter Nachrichten
|-
| Nachrichtenlänge || Maximale Größe einer Nachricht (Bytes)
|-
| Flags || Öffnungs- und Zugriffsmodi (z. B. O_RDONLY, O_NONBLOCK)
|}

Diese Parameter können beim Anlegen mit <code>mq_open()</code> übergeben werden.

---

== Wichtige Funktionen ==
{| class="wikitable"
! Funktion !! Beschreibung
|-
| <code>mq_open()</code> || Öffnet oder erzeugt eine Message Queue
|-
| <code>mq_send()</code> || Sendet eine Nachricht in die Queue
|-
| <code>mq_receive()</code> || Empfängt die älteste oder höchstpriorisierte Nachricht
|-
| <code>mq_close()</code> || Schließt die Queue im aktuellen Prozess
|-
| <code>mq_unlink()</code> || Löscht die Queue (wie <code>unlink()</code> für Dateien)
|-
| <code>mq_getattr()</code> / <code>mq_setattr()</code> || Liest oder ändert Attribute
|-
| <code>mq_notify()</code> || Registriert Benachrichtigung bei neuen Nachrichten
|}

---

== Beispiel: Einfacher Sender ==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <mqueue.h>
#include <fcntl.h>
#include <string.h>

#define QUEUE_NAME "/demoqueue"

int main() {
mqd_t mq;
struct mq_attr attr;
attr.mq_flags = 0;
attr.mq_maxmsg = 10; // maximal 10 Nachrichten
attr.mq_msgsize = 256; // maximal 256 Byte pro Nachricht
attr.mq_curmsgs = 0;

mq = mq_open(QUEUE_NAME, O_CREAT | O_WRONLY, 0644, &attr);
if (mq == (mqd_t)-1) {
perror("mq_open");
exit(EXIT_FAILURE);
}

char message[256];
sprintf(message, "Hallo vom Sender!");

if (mq_send(mq, message, strlen(message) + 1, 5) == -1) {
perror("mq_send");
} else {
printf("Nachricht gesendet.\n");
}

mq_close(mq);
return 0;
}
</syntaxhighlight>

---

== Beispiel: Einfacher Empfänger ==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <mqueue.h>
#include <fcntl.h>
#include <string.h>

#define QUEUE_NAME "/demoqueue"

int main() {
mqd_t mq;
char buffer[256];
unsigned int prio;

mq = mq_open(QUEUE_NAME, O_RDONLY);
if (mq == (mqd_t)-1) {
perror("mq_open");
exit(EXIT_FAILURE);
}

if (mq_receive(mq, buffer, sizeof(buffer), &prio) >= 0) {
printf("Empfangen (Priorität %u): %s\n", prio, buffer);
} else {
perror("mq_receive");
}

mq_close(mq);
mq_unlink(QUEUE_NAME); // Queue entfernen
return 0;
}
</syntaxhighlight>

'''Beispielausgabe:'''
<pre>
$ ./sender
Nachricht gesendet.
$ ./empfaenger
Empfangen (Priorität 5): Hallo vom Sender!
</pre>

---

== Beispiel: Nicht-blockierende Nutzung ==
<syntaxhighlight lang="c">
mq = mq_open("/demoqueue", O_RDONLY | O_NONBLOCK);
if (mq_receive(mq, buffer, sizeof(buffer), &prio) == -1) {
if (errno == EAGAIN)
printf("Keine Nachrichten vorhanden.\n");
}
</syntaxhighlight>

---

== Beispiel: Benachrichtigung über neue Nachrichten ==
Ein Prozess kann sich mit <code>mq_notify()</code> registrieren, um ein Signal oder einen Thread-Callback zu erhalten, wenn eine neue Nachricht eintrifft.

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <mqueue.h>
#include <signal.h>

#define QUEUE_NAME "/demoqueue"

void handler(union sigval sv) {
mqd_t mq = *((mqd_t*)sv.sival_ptr);
char msg[256];
unsigned int prio;
mq_receive(mq, msg, sizeof(msg), &prio);
printf("Neue Nachricht (Prio %u): %s\n", prio, msg);
}

int main() {
mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_RDONLY, 0644, NULL);

struct sigevent sev;
sev.sigev_notify = SIGEV_THREAD;
sev.sigev_notify_function = handler;
sev.sigev_notify_attributes = NULL;
sev.sigev_value.sival_ptr = &mq;

mq_notify(mq, &sev); // registrieren

printf("Warte auf Nachrichten...\n");
while (1) pause();
}
</syntaxhighlight>

---

== Attribute einer Queue ==
<syntaxhighlight lang="c">
struct mq_attr attr;
mq_getattr(mq, &attr);

printf("Max. Nachrichten: %ld\n", attr.mq_maxmsg);
printf("Nachrichtengröße: %ld\n", attr.mq_msgsize);
printf("Aktuelle Nachrichten: %ld\n", attr.mq_curmsgs);
</syntaxhighlight>

---

== Vergleich mit anderen IPC-Mechanismen ==
{| class="wikitable"
! Mechanismus !! Kommunikationstyp !! Besonderheiten
|-
| [[Pipe (Unix)]] || Stream (Bytestrom) || einfach, unstrukturiert
|-
| [[FIFO (Named Pipe)]] || Stream || über Dateisystemname erreichbar
|-
| [[POSIX Message Queues]] || Nachricht (strukturiert, priorisiert) || speicherbasiert, modern
|-
| [[System-V Message Queues]] || Nachricht || älter, weniger portabel
|-
| [[Unix Domain Sockets]] || Stream oder Datagram || flexibel, duplex, bidirektional
|-
| [[Shared Memory]] || Speicherzugriff || extrem schnell, aber Synchronisation nötig
|}

---

== Vorteile ==
* Nachrichtenorientiert (keine Bytestreams)
* Priorisierung integriert
* Blockierendes oder nicht-blockierendes Verhalten möglich
* Ereignisbenachrichtigung (mq_notify)
* POSIX-standardisiert und portabel

== Nachteile ==
* Begrenzte Nachrichtenlänge
* Verwaltung durch Kernel (etwas Overhead)
* Nur auf demselben System verfügbar (nicht über Netzwerk)

---

== Typische Einsatzgebiete ==
* Kommunikation zwischen Prozessen mit klarer Nachrichtenstruktur
* Ereignisbasierte Systeme (Produzent–Konsument)
* GUI–Daemon-Kommunikation
* Steuer- und Regelprozesse in Embedded-Systemen
* Ersatz für Pipes bei strukturierter Datenübertragung

---

== Siehe auch ==
* [[Interprozesskommunikation (IPC)]]
* [[POSIX Shared Memory]]
* [[Unix Domain Sockets]]
* [[Named Pipe (FIFO)]]
* [[System-V Message Queue]]
* [[POSIX Threads]]

---

== Quellen ==
* IEEE Std 1003.1-2001 – POSIX Realtime Extensions
* Stevens, W. Richard: ''UNIX Network Programming, Vol. 2: Interprocess Communications'', Prentice Hall
* The Linux Programming Interface – Michael Kerrisk, 2010
* Linux man pages: <code>man mq_overview</code>, <code>man mq_open</code>
* GNU C Library Documentation

POSIX Message Queues - Versionsgeschichte

PhilKa am 21. Oktober 2025 um 14:03 Uhr