Threads. Netzwerk - Programmierung. Alexander Sczyrba Jan Krüger

Transkript

1 Netzwerk - Programmierung Threads Alexander Sczyrba asczyrba@cebitec.uni-bielefeld.de Jan Krüger jkrueger@cebitec.uni-bielefeld.de

2 Übersicht Probleme mit fork Threads Perl threads API Shared Data Mutexes

3 Probleme mit fork fork ist teuer : Speicher wird für den Kindsprozess kopiert Alle Deskriptoren werden dupliziert Interprocess Communication (IPC) zur Kommunikation zwischen Parent und Child nötig Übergabe for dem fork einfach Rückgabe von Informationen (Child zum Parent) schwieriger

4 Thread Auch : leightweigth process oder LWP Jeder Thread läuft unabhängig von anderen Threads in einem gemeinsamen Prozess Erzeugen von einem Thread ist x schneller als das Erzeugen eines Prozesses Alle Threads eines Prozesses teilen den gleichen globalen Speicher Vereinfacht Austausch von Daten Aber : Synchronisation nötig

5 Threads(2) Threads eines Prozesses teilen u.a. Globale Variablen Geöffnete Dateien (z.b. Datei Deskriptoren) Signal Handlers Jeder Thread hat u.a. eigene(n) Thread ID Register (inkl. Program counter und stack pointer) Stack (für lokale Variablen und Rücksprungadressen)

6 Aufgabe Der Befehl top bzw. htop zeigt Informationen über die zur Zeit laufenden Prozesse an OSX (ports) : sudo ports install htop GZI/Linux: /homes/jkrueger/.bin/htop starte [h]top und beobachte, welche Prozesse Threads benutzen Achtung! Evtl. muss die Ansicht angepasst werden beschränke [h]top auf Deine eigene Prozesse starte den ServiceServer

7 Native Threads Implementation von Threads abhängig vom Betriebssystem und evtl. dessen Version 3 Kategorien von Threads: User-mode Threads Kernel Threads Mulitprocessor Kernel Threads

8 User mode Threads OS kennt keine Threads Auschliesslich im Programm (und dessen Bibliotheken) implementiert Problem Wenn ein Prozess blockiert, blockieren alle Kernel blockiert auf Prozess Ebene

9 Kernel Threads OS kennt Kernel Threads Blockieren eines Threads blockiert die anderen nicht Kernel blockiert auf Thread Ebene Aber: Prozess kann nicht mehrere Threads gleichzeitig laufen lassen Problem : Synchronisation

10 Erzeugen von Threads (in Perl) use threads; my $thr = threads->create(\&sub1, 1, Thread 1 ); sub sub1 { my $thr_no = shift; my $thr_name = shift; print in the thread : Thread_no $thr_no ($thr_name)\n ; Create benötigt Referenz auf Subroutine und evtl. eine Liste von Parametern Thread wird in der Subroutine gestartet Kontrolle wird an die Subroutine und Caller übergeben

11 Warten auf einen Thread Subroutinen der Threads können Werte zurückgeben Warten auf einen Thread und dessen Rückgabewerte mit join use threads; my $thr = threads->create(\&sub1, 1, Thread 1 ); my $ret_value = $thr->join; sub sub1 { my $thr_no = shift; my $thr_name = shift; print in the thread : Thread_no $thr_no ($thr_name)\n ;

12 Ignorieren eines Threads Kein Interesse an Rückgabewerten? Egal, wann der Thread terminiert? Detach Methode use threads; my $thr = threads->create(\&sub1, 1, Thread 1 ); $thr->detach; # do something else in the main thread sub sub1 { my $thr_no = shift; my $thr_name = shift; print in the thread : Thread_no $thr_no ($thr_name)\n ;

13 Thread Methoden $thread = threads >self Thread-Objekt des aufrufenden Threads $id = $thread->tid() gibt die ID des Thread-Objekts = threads->list() Liste aller non-joined, non-detached threads

14 Aufgaben schreibe ein Programm, das einen Thread erzeugt der Thread soll die globale Variable $count 500 mal inkrementieren gib jeweils den aktuellen Wert der Variable $count im Thread aus benutze an geeigneten Stellen sleep, um das Verhalten Deines Programms mit [h]top zu verfolgen gib die Variable nochmal aus, nachdem der Thread joined wurde Was fällt Dir auf?

15 Shared Data Ausnahme in Perl: keine Daten shared by default alle Daten werden von einem zum anderen Thread kopiert Shared Data mit: use threads; use threads::shared; my $foo : shared = 1; my $bar = 1; threads->create(sub { $foo++; $bar++ })->join; print "$foo\n"; # prints 2 since $foo is shared print "$bar\n"; # prints 1 since $bar is not shared

16 Aufgabe Ändere Dein Programm so ab, dass shared data benutzt wird Starte 2 Threads nacheinander, um die $count Variable bis zu inkrementieren Starte die Threads gleichzeitig Was fällt Dir auf?

17 Race Conditions use threads; use threads::shared; my $a : shared = 1; $thr1 = threads->new(&sub1); $thr2 = threads->new(&sub2); $thr1->join; $thr2->join; print "$a\n"; sub sub1 { my $foo = $a; $a = $foo + 1; } sub sub2 { my $bar = $a; $a = $bar + 1; }

18 Mutexes bei shared data ist Synchronisation zwischen Threads nötig Sperren einer shared Variable durch Mutex (mutual exclusion) möglich Zugriff auf Variable erfolgt erst nach Erhalt der Mutex der Versuch, eine bereits gesperrte Variable zu sperren, blockiert #include <pthread.h> int pthread_mutex_lock(pthread_mutex_t *mptr); int pthread_mutex_unlock(pthread_mutex_t *mptr);

19 Synchronisation in Perl Perl benutzt andere Techniken zum Sperren von Variablen lock() Funktion sperrt Variable kein unlock() in Perl, sperrt bis Variable out of scope ist use threads; use threads::shared; my $count : shared = 0; my $thr = threads->create(&calc); sub calc { lock($count); # block until we obtain the lock $count = $count+1; }

20 Aufgabe Ändere Dein Counter-Programm so ab, dass die Variable vorher gesperrt wird. Bekommst Du jetzt das erwartete Ergebnis?