Linux Gegestück für Windows Events

[Schnoogle]

Hallo,

ich muss unter Linux eine Schnittstelle erstellen, die den Aufrufer darüber informieren können soll, dass ein bestimmten Ereignis aufgetreten ist.

Mit der Win32-API habe ich so einen Mechanismus über einen Windows Event Handle implementiert. Dabei habe ich folgende Funktionen verwendet.

HANDLE handle = CreateEvent(...);

//...

SetEvent(&handle);

//...

WaitForSingleObject(&handle, ...)

Kann mir jemand hierfür einen Äquivalenten Mechanismus unter Linux nennen ? Ich möchte es wohl so verwenden, dass ein Thread SetEvent() aufruft und dadurch einen anderen Thread aufweckt, der mit WaitForSingleObject() auf das Event wartet.

 

[Matthias Reitinger]

Hallo Schnoogle,

falls du pthread verwendest, könntest du das mit einem Mutex oder Condition Variables lösen.

Grüße,
Matthias

 

[CPoly]

Unter Unix gibts es Signale. Vielleicht passt das zu deinen Anforderungen.
http://de.wikipedia.org/wiki/Signal_(Computer)

Edit: Signale sind afaik asynchron, also du "wartest" nicht aktiv darauf.

 

[Schnoogle]

Hallo,

danke für die Vorschläge. Ich werde es mit den Signalen probieren.

Gruß

 

[Matthias Reitinger]

Hallo Schnoogle,

Signale sind eher für Interprozesskommunikation gedacht und nicht zur Synchronisierung von Threads. Wenn ich dein Anliegen richtig verstanden habe, sind sie deswegen hier nicht gerade die beste Wahl.

Grüße,
Matthias

 

[Schnoogle]

Hallo,

danke schön für den Hinweis.

Ich kann ja mein Anliegen etwas detailierter erklären.

Also ich erstelle eine abstrakte Schnittstelle (C-Header) für einen Programmierer, bei dem ich davon ausgehe, dass er über weniger Fachwissen und Erfahrung verfügt als ich. Klingt komisch, ist aber so

Innerhalb der Implementierung der Schnittstelle wartet ein Thread (pthread) auf den Empfang einer Nachricht über einen Socket. Sobald eine Nachricht empfangen wird, werden die Nutzdaten (ohne Protokoll) ausgepackt und in einer bestimmten Queue abgelegt.

Die Signale wollte ich dafür verwenden, um einen Thread der sich oberhalb der API befindet, darüber zu informieren, dass die o.g. Queue einen bestimmten Füllstatus erreicht hat. Dieser soll dann die Queue auslesen ...

An einen Mutex oder gar eine Semaphore habe ich auch schon gedacht. Eine Semaphore würde sich bei einer Queue wohl auch gut eignen ... Aber ich habe jedoch gehört, dass Mutex und Semaphore relativ viele Recourcen benötigen. Und das Problem ist, ich habe nur eine CPU bzw. einen Core. Ich verwende die Threads nur, damit nichts blockiert wird ...

 

[RedWing]

Hallo,

ich würde es so lösen das ich dem Nutzer einfach eine Schnittstelle anbiete mit welcher er eine Handlerfunktion (Callback) registrieren kann. Diese Callback wird dann entsprechend von deinem API Thread aufgerufen wenn die Queue bspw. voll ist:

Der Nutzer definiert dann bspw. die Handler-Implementierung und registriert diesen zur Initialisierung:

void user_queue_full_handler(message_queue_t *mq, void *user_data)
{
  /* lies queue aus */
}

int main()
{
   // init phase
   register_queue_full_handler(user_queue_full_handler, NULL);
}

Und deine API stellt dann entsprechend die Funktion zur Registrierung zur Verfügung:

typedef void (*queue_handler_t)(message_queue_t *mq, void *user_data);

queue_handler_t queue_full_handler = NULL;
void *handler_data;

void register_queue_full_handler(queue_handler_t *handler, void *user_data)
{
  queue_full_handler = handler;
  handler_data = user_data;
}

Der Api Thread ruft dann je nach Füllstatus deiner Queue die entsprechende Callback auf:

message_queue_t queue;
message_t message;

void api_thread()
{
  while(1)
    {
      waitformessage();
      put (message, queue);
      if (queue_full_handler && full(queue))
        {
          queue_full_handler(queue, handler_data);
        }
    }
}

Somit hat der Benutzer genügend Flexibilität um selbst bspw. einen Mutex (wenn er eine Multithreadanwendung schreiben mag) zu implementieren oder weiß der Teufel wie die Queue entsprechend auszulesen.

HTH,
RedWing