SDL: Threads

Threads dienen dazu, Aufgaben gleichzeitig oder scheinbar gleichzeitig durchzuführen. Es kann unter Umständen sinnvoll sein, Threads einzurichten, die sich beispielsweise um die Musik während eines Spieles kümmern. Bitte beachte Sie, dass Threads selbst durch den Wechsel von einem Thread zu einem anderen Rechenzeit kosten. Unter Umständen wird eine Anwendung mit Threads langsamer laufen als ohne. Echt Gleichzeitig können Aufgaben nur dann erfolgen, wenn Sie Gebrauch von einer zweiten CPU machen können.

Threads einrichten und verwalten

Threads erzeugen

Ein Thread wird repräsentiert durch eine Funktion folgender Gestalt

 int mein_thread (void* parameter);

Um einen Thread zu erzeugen, ruft man folgende Funktion auf:

 SDL_Thread *SDL_CreateThread (int (*thread_func)(void*), void *thread_parameter);

Diese Funktion erwartet obige Funktion als Argument, der Parameter thread_parameter wird direkt an den eigentlichen Thread übergeben.

Threads beenden

Die Funktion

void SDL_KillThread (SDL_Thread *thread);

beendet den laufenden Thread sofort. Der Thread hat keine Möglichkeiten mehr, evtl. anstehende Aufräumarbeiten zu erledigen.

Warten auf das Ende

Mit der Funktion

void SDL_WaitThread (SDL_Thread *thread, int *status);

wartet man auf das Beenden des Threads. Man wartet unendlich lange, wenn der Thread eine Endlosschleife implementiert. Der Rückgabewert der Threadfunktion wird in status übergeben.

Sonstiges

Die Funktionen

 Uint32 SDL_GetThreadID(SDL_Thread *thread);

und

 Uint32 SDL_ThreadID (void);

übergeben eine 32-Bit Zahl, die den Thread eindeutig benennt.

Beispiel

Das folgende Beispiel implementiert zwei Threads. Innerhalb der Threads werden Rechtecke an zufälligen Positionen erzeugt

 rect.x = 1 + (int) (630 * (rand() / (RAND_MAX + 1.0)));
 rect.y = 1 + (int) (470 * (rand() / (RAND_MAX + 1.0)));

und anschließend gezeichnet. Die Threads selbst werden mit

 t1 = SDL_CreateThread (thread1, screen);
 t2 = SDL_CreateThread (thread2, screen);

erzeugt, der zusätzliche Parameter ist hier der Zeiger auf die Surface des Bildschirmes. Drückt der Benutzer die Escape-Taste, so werden beide Threads beendet mit

 SDL_KillThread(t1);
 SDL_KillThread(t2);

#include <stdlib.h>
#include <SDL.h>
#include <SDL_thread.h>

int thread1 (void *p)
{ 
  SDL_Rect rect;
  SDL_Surface *s = (SDL_Surface*) p;
  rect.x = 100;
  rect.y = 100;
  rect.w = 10;
  rect.h = 10;
  while (1)
    {
      rect.x = 1 + (int) (630 * (rand() / (RAND_MAX + 1.0)));
      rect.y = 1 + (int) (470 * (rand() / (RAND_MAX + 1.0)));
      SDL_FillRect (s, &rect, SDL_MapRGB (s->format, 255, 0, 0));
      SDL_UpdateRect (s, rect.x, rect.y, rect.w, rect.h);
      SDL_Delay (100);
    }
  return 0;
} 

int thread2 (void *p)
{ 
  SDL_Rect rect;
  SDL_Surface *s = (SDL_Surface*) p;
  rect.x = 100;
  rect.y = 100;
  rect.w = 10;
  rect.h = 10;
  while (1)
    {
      rect.x = 1 + (int) (630 * (rand() / (RAND_MAX + 1.0)));
      rect.y = 1 + (int) (470 * (rand() / (RAND_MAX + 1.0)));
      SDL_FillRect (s, &rect, SDL_MapRGB (s->format, 0, 255, 0));
      SDL_UpdateRect (s, rect.x, rect.y, rect.w, rect.h);
      SDL_Delay (100);
    }
  return 0;
} 

int main (void)
{
  SDL_Surface *screen;
  SDL_Event e;
  SDL_Thread *t1, *t2;
  int quit = 0;
  if (SDL_Init (SDL_INIT_VIDEO) == -1)
    {
      printf ("Kann SDL nicht initialisieren: %s\n", SDL_GetError ());
      exit (1);
    }
  atexit (SDL_Quit);
  screen = SDL_SetVideoMode (640, 480, 16, SDL_SWSURFACE);
  if (screen == NULL)
    {
      printf ("Video Modus kann nicht eingerichtet werden: %s\n", SDL_GetError());
      exit (1);
    }
  t1 = SDL_CreateThread (thread1, screen);
  t2 = SDL_CreateThread (thread2, screen);
  while (SDL_WaitEvent (&e) && !quit)
    switch (e.type)
      {
        case SDL_KEYDOWN:
          if (e.key.keysym.sym == SDLK_ESCAPE)
            {
              SDL_KillThread(t1);
              SDL_KillThread(t2);
              quit = 1;
            }
        break;
      }
  return 0;
}

Bitte nicht stören

Einleitendes Beispiel

Das folgende Programm versucht, nacheinander die Zeichenketten "aaaaa" und "bbbbb" auszugeben, eine Pause einzulegen und dann wieder von vorne zu beginnen. Bitte beachten Sie, daß hier keine Video-Ausgabe erfolgt. Das Programm funktioniert rein im Shell-Modus ohne eigenes Fenster.

#include <stdlib.h>
#include <SDL.h>
#include <SDL_thread.h>

int thread1 (void *p)
{
  while (1)
    {
      printf ("a");
      SDL_Delay (10);
      printf ("a");
      SDL_Delay (10);
      printf ("a");
      SDL_Delay (10);
      printf ("a");
      SDL_Delay (10);
      printf ("a");
      SDL_Delay (10);
      printf("\n");
      SDL_Delay (200);
    }
  return 0;
}

int thread2 (void *p)
{
  while (1)
    {
      SDL_Delay (10);
      printf ("b");
      SDL_Delay (10);
      printf ("b");
      SDL_Delay (10);
      printf ("b");
      SDL_Delay (10);
      printf ("b");
      SDL_Delay (10);
      printf("\n");
      SDL_Delay (200);
    }
  return 0;
}

int main (void)
{
  SDL_Thread *t1, *t2;
  if (SDL_Init (0) == -1)
    {
      printf ("Kann SDL nicht initialisieren: %s\n", SDL_GetError ());
      exit (1);
    }
  t1 = SDL_CreateThread (thread1, NULL);
  t2 = SDL_CreateThread (thread2, NULL);
  SDL_Delay (2000);
  SDL_KillThread (t1);
  SDL_KillThread (t2);
  SDL_Quit ();
  return 0;
}

Führen wir das Programm aus, passiert etwas sonderbares:

ababababab

ababababab

ababababab

ababababab

ababababab

ababababab

ababababab

Von einem "aaaaa", "bbbbb", wie wir es uns wünschen, ist wenig zu sehen, beide Threads überlagern sich und machen ihre Ausgaben, während der andere Thread jeweils ebenfalls Daten ausgibt. Wünschenswert wäre ein Modus, der Bitte nicht stören heißt und bedeutet, daß ein Thread exklusiv ausgeführt wird, ungestört von einem anderen Thread. Ein solcher kritischer Bereich (critic section) kann mit Hilfe eines Mutex erzeugt werden. Ein Mutex ist eine Art Fähnchen, welches derjenige Thread hochhält, der ungestört seine Arbeit verrichten will. Hinterher wird das Fähnchen wieder abgenommen, es werden wieder Störungen zugelassen.

Mutex erzeugen, entfernen

Ein Mutex wird erzeugt, indem

 SDL_mutex* SDL_CreateMutex (void);

aufgerufen wird.

Um ein Mutex wieder zu entfernen, kann

 void SDL_DestroyMutex (SDL_mutex *mutex);

aufgerufen werden.

Mutex setzen

Um mitzuteilen, daß der folgende Bereich kritisch ist und exklusiv ausgeführt wird, dient die Funktion

 int SDL_mutexP (SDL_mutex *mutex);

Die Funktion gibt 0 bei Erfolg zurück, sonst -1.

P steht für "proberen" und V im folgenden Abschnitt für "verhogen", dies sind die üblichen Bezeichnungen der beiden Funktionen nach ihrem Erfinder Dijkstra. Zur besseren Lesbarkeit des Codes existiert ein Makro namens SDL_LockMutex (mutex), welches diese Funktion ersetzt.

Mutex löschen

Nach Verlassen eines kritischen Bereiches wird die Funktion

 int SDL_mutexV (SDL_mutex *mutex);

aufgerufen. Die Rückgabewerte sind dieselben wie bei SDL_mutexP. Zu dieser Funktion existiert ein Makro namens SDL_UnlockMutex (mutex).

Beipiel mit Mutex

#include <stdlib.h>
#include <SDL.h>
#include <SDL_thread.h>

int thread1 (void *p)
{ 
  SDL_mutex *m = (SDL_mutex*) p;
  while (1)
    {
      SDL_LockMutex (m);
      printf ("a");
      SDL_Delay (10);
      printf ("a");
      SDL_Delay (10);
      printf ("a");
      SDL_Delay (10);
      printf ("a");
      SDL_Delay (10);
      printf ("a");
      SDL_Delay (10);
      printf("\n");
      SDL_UnlockMutex (m);
      SDL_Delay (200);
    }
  return 0;
}

int thread2 (void *p)
{ 
  SDL_mutex *m = (SDL_mutex*) p;
  while (1)
    {
      SDL_LockMutex (m);
      printf ("b");
      SDL_Delay (10);
      printf ("b");
      SDL_Delay (10);
      printf ("b");
      SDL_Delay (10);
      printf ("b");
      SDL_Delay (10);
      printf ("b");
      SDL_Delay (10);
      printf("\n");
      SDL_UnlockMutex (m);
      SDL_Delay (200);
    }
  return 0;
}

int main (void)
{ 
  SDL_Thread *t1, *t2;
  SDL_mutex *mutex;

  if (SDL_Init (0) == -1)
    {
      printf ("Kann SDL nicht initialisieren: %s\n", SDL_GetError ());
      exit (1);
    }

  mutex = SDL_CreateMutex ();
  t1 = SDL_CreateThread (thread1, mutex);
  t2 = SDL_CreateThread (thread2, mutex);
  SDL_Delay (2000);
  SDL_KillThread (t1);
  SDL_KillThread (t2);
  SDL_DestroyMutex (mutex);
  SDL_Quit ();
  return 0;
}

Die Ausgabe des Programmes ist nun:

aaaaa
bbbbb
aaaaa
bbbbb
aaaaa
bbbbb
aaaaa
bbbbb

wie gewünscht.

Semaphoren

<< Fensterdekor | Inhaltsverzeichnis