10.6 Die Attribute von Threads und das Scheduling 

Wie Sie bereits im Abschnitt zuvor erfahren haben, kann man auch das Attribut PTHREAD_CREATE_DETACHED zum Abhängen (detached) von Threads verwenden. Hierzu können die folgenden Funktionen verwendet werden:

#include <pthread. h.>
int pthread_attr_init( pthread_attr_t *attribute );
int pthread_attr_getdetachestate( pthread_attr_t *attribute,
                                  int detachstate );
int pthread_attr_setdetachestate( pthread_attr_t *attribute,
                                  int detachstate );
int pthread_attr_destroy( pthread_attr_t *attribute );

Mit der Funktion pthread_attr_init() müssen Sie zunächst das Attributobjekt attr initialisieren. Dabei werden auch gleich die voreingestellten Attribute gesetzt. Um beim Thema »detached« und »joinable« zu bleiben, ist die Voreinstellung hier PTHREAD_CREATE_JOINABLE, hiermit wird also der Thread nicht von den anderen losgelöst und erst freigegeben, wenn ein Thread nach dem Exit-Status diese Threads fragt (mit pthread_join()). Mit der Funktion pthread_attr_getdetachestate() können Sie das »detached«-Attribut erfragen, und mit pthread_attr_setdetachedstate() wird es gesetzt. Neben dem eben erwähnten PTHREAD_CREATE_JOINABLE, was ja auch die Standardeinstellung eines erzeugten Threads ist, können Sie hierbei auch PTHREAD_CREATE_DETACHED verwenden. Das Setzen von PTHREAD_CREATE_DETACHED entspricht exakt dem Verhalten der Funktion pthread_detach() (siehe Kap. 9.5.6) und kann auch stattdessen verwendet werden – da es erheblich kürzer ist. Benötigen Sie das Attributobjekt attr nicht mehr, können Sie es mit pthread_attr_destroy() löschen. Somit machen die Funktionen wohl erst Sinn, wenn Sie bereits mit pthread_detach() einen Thread ausgehängt haben und diesen eventuell wieder zurückholen (PTHREAD_CREATE_JOINABLE) müssen.

Bedeutend wichtiger im Zusammenhang mit den Attributen von Threads erscheint hier schon das Setzen der Prozessorzuteilung (Scheduling). Laut POSIX gibt es drei verschiedene solcher Prozesszuteilungen (Scheduling Policies):

SCHED_OTHER – Die normale Priorität wie bei einem gewöhnlichen Prozess. Der Thread wird beendet, entweder wenn seine Zeit um ist und er wartet, bis er wieder am Zuge ist, oder wenn ein anderer Thread oder Prozess gestartet wurde, der mit einer höheren Priorität ausgestattet ist.

Echtzeit (SCHED_FIFO) – Dies sind Echtzeitprozesse. Sie werden in jedem Fall SCHED_OTHER-Prozessen vorgezogen. Auch können sie nicht von normalen Prozessen unterbrochen werden. Es gibt drei Möglichkeiten, Echtzeitprozesse zu unterbrechen:

Echtzeit (SCHED_RR) – Dies sind Round-Robin-Echtzeitprozesse. Beim Round-Robin-Verfahren hat jeder Prozess die gleiche Zeitspanne zur Verfügung. Ist diese verstrichen, so kommt der nächste Prozess an die Reihe. Unter Linux werden diese Prozesse genauso behandelt wie die Echtzeitprozesse, mit dem Unterschied, dass diese an das Ende der run-queue gesetzt werden, wenn sie den Prozessor verlassen.

Jetzt habe ich hier Echtzeitoperationen ins Spiel geworfen und sollte daher hierzu einen kurzen Exkurs machen, damit man die Echtzeitstrategie nicht mit »jetzt – gleich sofort« vergleicht. Die Abarbeitung von Daten in der Echtzeit kann einfach nicht sofort ausgeführt werden, sondern auch hier muss man sich damit begnügen, dass diese innerhalb einer vorgegebenen Zeitspanne abgearbeitet werden. Allerdings müssen solche Echtzeitoperationen auch unterbrechbar sein, um auf plötzliche unvorsehbare Ereignisse reagieren zu können. Daher unterscheidet man hier zwischen »weichen« und »harten« Echtzeitanforderungen. Die Anforderungen hängen vom Anwendungsfall ab, so kann man bei einem Computerspiel jederzeit »weiche« Echtzeitanforderungen setzen – was bei Maschinenanforderungen wohl eher katastrophal sein kann. Hier muss innerhalb einer vorgegebenen Zeit reagiert werden. Der Hauptbereich von Echtzeitanwendungen ist immer noch:

Multimedia - Audio, Video

Steuerung, Regelung - Maschinen-, Robotersteuerung

Damit eine solche Zuteilungsstrategie auch funktioniert, muss das System diese auch unterstützen. Dies ist gegeben, wenn bei Ihnen die Konstante _POSIX_THREAD_PRIORITY_SCHEDULING definiert ist. Beachten Sie außerdem, dass die Echtzeit-Zuteilungsstrategien SCHED_FIFO und SCHED_RR nur vom Superuser root ausgeführt werden können.

Verändern bzw. erfragen der Zustellungsstrategie können Sie mit den folgenden Funktionen:

int pthread_setschedparam( pthread thread, int policy,
                           const struct sched_param *param);
int pthread_getschedparam( pthread thread, int policy,
                           struct sched_param *param);

Mit diesen Funktionen setzen (set) oder ermitteln (get) Sie die Zustellungsstrategie eines Threads mit der ID thread vom Typ pthread_t. Die Strategie legen Sie mit dem Parameter policy fest. Hierbei kommen die bereits beschriebenen Konstanten SCHED_OTHER, SCHED_FIFO und SCHED_RR in Frage. Mit dem letzten Parameter der Struktur sched_param, die sich in der Headerdatei <bits/sched. h.> befindet:

/* Struktur sched_param */
struct sched_param {
    int sched_priority;
};

legen Sie die gewünschte Priorität fest.

Das folgende Beispiel soll Ihnen zeigen, wie einfach es ist, die Zuteilungsstrategie und die Priorität zu verändern. Sie finden hierbei zwei Funktionen, eine, womit Sie die Strategie und Priorität abfragen können, und eine weitere, womit Sie diese Werte neu setzen können. Allerdings benötigen Sie für das Setzen Superuser-root-Rechte, was im Beispiel ebenfalls ermittelt wird.

/* thread4.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd. h.>
#include <pthread. h.>
#define MAX_THREADS 3
#define BUF 255
/* Funktion ermittelt die Zuteilungsstrategie *
 * und Priorität eines Threads */
static void getprio( pthread_t id ) {
   int policy;
   struct sched_param param;
   printf("\t->Thread %ld: ", id);
   if((pthread_getschedparam(id, &policy, &param)) == 0  ) {
      printf("Zuteilung: ");
      switch( policy ) {
         case SCHED_OTHER :  printf("SCHED_OTHER; "); break;
         case SCHED_FIFO  :  printf("SCHED_FIFO; ");  break;
         case SCHED_RR    :  printf("SCHED_RR; ");    break;
         default          :  printf("Unbekannt; ");  break;
      }
      printf("Priorität: %d\n", param.sched_priority);
   }
}
/* Funktion zum Setzen der Zuteilungsstrategie *
 * und Prioriät eines Threads */
static void setprio( pthread_t id, int policy, int prio ) {
   struct sched_param param;
   param.sched_priority=prio;
   if((pthread_setschedparam( pthread_self(),
                              policy, &param)) != 0  ) {
      printf("Konnte Zuteilungsstrategie nicht ändern\n");
      pthread_exit((void *)pthread_self());
   }
}
static void thread_prio_demo(void *name) {
   int policy;
   struct sched_param param;
   /*Aktuelle Zuteilungsstrategie und Priorität erfragen */
   getprio(pthread_self());
   /* Ändern darf hier nur der root */
   if( getuid() != 0 ) {
      printf("Verändern geht nur mit Superuser-Rechten\n");
      pthread_exit((void *)pthread_self());
   }
   /* Neue Zuteilungsstrategie und Priorität festsetzen */
   setprio(pthread_self(), SCHED_RR, 2);
   /* Nochmals abfragen, ob erfolgreich verändert ... */
   getprio(pthread_self());
   /* Thread-Ende */
   pthread_exit((void *)pthread_self());
}
int main (void) {
   int i;
   static int ret[MAX_THREADS];
   static pthread_t th[MAX_THREADS];
   printf("->Haupt-Thread (ID:%ld) gestartet ...\n",
      pthread_self());
   /* Threads erzeugen */
   for (i = 0; i < MAX_THREADS; i++) {
      if (pthread_create ( &th[i],NULL, &thread_prio_demo,
                           NULL) != 0) {
         printf ("Konnte keinen Thread erzeugen\n");
         exit (EXIT_FAILURE);
      }
   }
   /* Auf die Threads warten */
   for (i = 0; i < MAX_THREADS; i++)
      pthread_join (th[i], &ret[i]);
   /* Rückgabe der Threads auswerten */
   for (i = 0; i < MAX_THREADS; i++)
      printf("\t<-Thread %ld mit Arbeit fertig\n", ret[i]);
   printf("->Haupt-Thread (ID:%ld) fertig ...\n",
      pthread_self());
   return EXIT_SUCCESS;
}

Das Programm bei der Ausführung:

$ gcc -o thread4 thread4.c -lpthread
$ ./thread4
->Haupt-Thread (ID:-1209412512) gestartet...
        ->Thread -1209414736: Zuteilung: SCHED_OTHER; Priorität: 0
!!! Verändern geht nur mit Superuser-Rechten!!!
        ->Thread -1217807440: Zuteilung: SCHED_OTHER; Priorität: 0
!!! Verändern geht nur mit Superuser-Rechten!!!
        ->Thread -1226200144: Zuteilung: SCHED_OTHER; Priorität: 0
!!! Verändern geht nur mit Superuser-Rechten!!!
        <-Thread -1209414736 mit Arbeit fertig
        <-Thread -1217807440 mit Arbeit fertig
        <-Thread -1226200144 mit Arbeit fertig
->Haupt-Thread (ID:-1209412512) fertig ...
$ su
Password:********
# ./thread4
->Haupt-Thread (ID:-1209412512) gestartet ...
->Thread -1209414736: Zuteilung: SCHED_OTHER; Priorität: 0
->Thread -1209414736: Zuteilung: SCHED_RR; Priorität: 2
->Thread -1217807440: Zuteilung: SCHED_OTHER; Priorität: 0
->Thread -1217807440: Zuteilung: SCHED_RR; Priorität: 2
->Thread -1226200144: Zuteilung: SCHED_OTHER; Priorität: 0
->Thread -1226200144: Zuteilung: SCHED_RR; Priorität: 2
        <-Thread -1209414736 mit Arbeit fertig
        <-Thread -1217807440 mit Arbeit fertig
        <-Thread -1226200144 mit Arbeit fertig
->Haupt-Thread (ID:-1209412512) fertig ...

Selbiges (Zuteilungsstrategien und Priorität) können Sie übrigens mit folgenden Funktionen auch über Attributobjekte (pthread_attr_t) setzen bzw. erfragen:

#include <pthread. h.>
/* Zuteilungsstrategie verändern bzw. erfragen */
int pthread_attr_setschedpolicy( pthread_attr_t *attr,
                                 int policy);
int pthread_attr_getschedpolicy( const pthread_attr_t *attr,
                                 int *policy);
/* Priorität verändern bzw. erfragen */
int pthread_attr_setschedparam(
   pthread_attr_t *attr, const struct sched_param *param );
int pthread_attr_getschedparam(
   const pthread_attr_t *attr, struct sched_param *param );

Wollen Sie außerdem festlegen bzw. abfragen, wie ein Thread seine Attribute (Zuteilungsstrategie und Priorität) vom Erzeuger-Thread übernehmen soll, stehen Ihnen folgende Funktionen zur Verfügung:

#include <pthread. h.> 
int pthread_attr_setinheritsched(
   pthread_attr_t *attr, int inheritsched );
int pthread_attr_getinheritsched(
   const pthread_attr_t *attr, int *inheritsched );

Mit den beiden Funktionen phtread_attr_getinheritsched() und phtread_attr_setinheritsched() können Sie abfragen bzw. festlegen, wie der Thread die Attribute vom »Eltern«-Thread übernimmt. Dabei gibt es zwei Möglichkeiten – PTHREAD_INHERIT_SCHED, was bedeutet, dass der Kind-Thread die Attribute (mitsamt Zuteilungsstrategie und der Priorität) des Eltern-Threads übernimmt, und PTHREAD_EXPLICIT_SCHED bedeutet, eben nichts zu übernehmen, sondern das zu verwenden, was in attr als Zuteilungsstrategie und Priorität festgelegt ist. Wurden die Attribute des »Eltern«-Threads nicht verändert, so ist der Kind-Thread dennoch (logischerweise) mit denselben Attributen wie der »Eltern«-Thread ausgestattet – da Standardattribute.