Brief introduction into some basic topics of Java threading.

1. Thread
Programmierung in Java
und einige Synchronisationsmechanismen

2. Multi-Tasking bei
Betriebssystemen
Programme laufen
quasi-parallel

3. 2 Kerne 4 Kerne 24 Kerne

4. Sie lernen kennen
• Parallele Ausführung von Algorithmen
• Gleichzeitiger Zugriff auf Ressourcen
• Mechanismen zur Synchronisation
• Methode / Best Practices

5. Parallele Algorithmen
Parallele Parallele
Verarbeitung Verarbeitung
von Aufgaben von Daten
(task decomposition) (data decomposition)

6. int[] data = initializeArray();
for( int i = 0; i<data.length; i++ )
{
data[i] = data[i] * 2;
}

7. int[] data = initializeArray();
for( int i = 0; i<data.length; i++ )
{
data[i] = data[i] * 2;
}

8. int[] data = initializeArray();
for( int i = 0; i<data.length; i++ )
{
data[i] = data[i] * 2;
}
Kern #1

9. int[] data = initializeArray();
for( int i = 0; i<data.length; i++ )
{
data[i] = data[i] * 2;
}
0 1 2 3 4 5 6 7 8 9
Kern #1

10. int[] data = initializeArray();
for( int i = 0; i<data.length; i++ )
{
data[i] = data[i] * 2;
}
0 1 2 3 4 5 6 7 8 9
Kern #1
Kern #2

11. int[] data = initializeArray();
for( int i = 0; i<data.length; i++ )
{
data[i] = data[i] * 2;
}
0 1 2 3 4
Kern #1
Kern #2

12. import java.lang.Thread;
public class MyThread extends Thread
{
public void run()
{
// Code an dieser Stelle wird
// nebenläufig ausgeführt
// sobald der Thread startet
}
}
Der Thread muss noch durch Aufruf der
Methode start() gestartet werden.

13. public static void main( String[] args )
{
MyThread t = new MyThread();
t.start();
System.out.println(„Thread läuft“);
t.join();
}

14. public static void main( String[] args )
{
MyThread t = new MyThread();
t.start();
System.out.println(„Thread läuft“);
t.join();
}

15. Thread #1
public static void main( String[] args )
{
MyThread t = new MyThread();
t.start();
System.out.println(„Thread läuft“);
t.join();
}
Zeit

16. Thread #1
public static void main( String[] args )
{
MyThread t = new MyThread();
t.start();
System.out.println(„Thread läuft“);
t.join();
}
Zeit

17. Thread #1
public static void main( String[] args )
{
MyThread t = new MyThread();
t.start();
System.out.println(„Thread läuft“);
t.join();
}
Zeit

18. Thread #1
public static void main( String[] args )
{
MyThread t = new MyThread();
t.start();
System.out.println(„Thread läuft“);
t.join();
}
Zeit

19. Thread #1
public static void main( String[] args )
{
MyThread t = new MyThread();
Thread #2
t.start(); public void run()
{
System.out.println(„Thread läuft“);
t.join();
}
}
Zeit

20. Thread #1
public static void main( String[] args )
{
MyThread t = new MyThread();
Thread #2
t.start(); public void run()
{
System.out.println(„Thread läuft“);
t.join();
}
}
Zeit

21. Thread #1
public static void main( String[] args )
{
MyThread t = new MyThread();
Thread #2
t.start(); public void run()
{
System.out.println(„Thread läuft“);
t.join();
}
}
Zeit

22. class MyThread extends Thread
{
private int[] data;
private int start;
private int end;
public MyThread( int[] data, int start, int end )
{
this.data = data;
this.start = start;
this.end = end;
}
public void run()
{
for( int i=start; i<end; i++ )
{
data[i] = data[i] * 2;
}
}
}

23. public static void main( String[] args )
{
int[] data = initializeArray();
int length = data.length;
int half = length / 2;
MyThread t1 = new MyThread( data, 0, half );
MyThread t2 = new MyThread( data, half, length );
t1.start();
t2.start();
t1.join();
t2.join();
}

24. Vergleich der Performance

25. Vergleich der Performance
data.length mit 1 Thread mit 2 Threads
100 2 ms 2 ms
1000 5 ms 5 ms
10,000 41 ms 31 ms
100,000 414 ms 254 ms
1,000,000 4130 ms 2093 ms
10,000,000 41288 ms 26739 ms

26. int[] data = new int[10];
data[0] = initialValue();
for( int i = 1; i<data.length; i++ )
{
data[i] = data[i-1] + 1;
}

27. int[] data = new int[10];
data[0] = initialValue();
for( int i = 1; i<data.length; i++ )
{
data[i] = data[i-1] + 1;
}
index 0 1 2 3 4 5 6 7 8 9
value 0 1 2 3 4 5 6 7 8 9

28. Paralleler Zugriff auf
gemeinsame Ressourcen

29. public class BankAccount
{
private int balance;
public void deposit( int amount )
{
int temp = this.balance + amount;
this.balance = temp;
}
}

30. public class BankAccount
{
private int balance;
public void deposit( int amount )
{
int temp = this.balance + amount;
this.balance = temp;
}
}
Step Thread 1: deposit(100); Thread 2: deposit(200); balance
1 temp = this.balance + amount; temp = this.balance + amount; 0
2 this.balance = temp; 100
3 this.balance = temp; 200

31. public class BankAccount
{
private int balance;
public synchronized void deposit( int amount )
{
int temp = this.balance + amount;
this.balance = temp;
}
}

32. public class BankAccount
{
private int balance;
public synchronized void deposit( int amount )
{
int temp = this.balance + amount;
this.balance = temp;
}
}
Step Thread 1: deposit(100); Thread 2: deposit(200); balance
1 temp = this.balance + amount; 0
2 this.balance = temp; 100
3 temp = this.balance + amount; 100
4 this.balance = temp; 300

33. public class BankAccount
{
private int balance;
public void deposit( int amount )
{
synchronized( this )
{
int temp = this.balance + amount;
this.balance = temp;
}
}
}
Die synchronized Anweisung erzeugt
einen Lock auf dem angegebenen Objekt
zur Absicherung einer kritischen Region.

34. public class BankAccount
{
private int balance;
public void deposit( int amount )
{
synchronized( this )
{
int temp = this.balance + amount;
this.balance = temp;
}
}
}
Ein wartender Thread hat keine Kontrolle mehr.
Nur ein Thread kann die kritische Region betreten.

35. public class BankAccount
{
private int balance;
private Lock lock = new ReentrantLock();
public void deposit( int amount )
{
boolean acquired = lock.tryLock( 500,
TimeUnit.MILLISECONDS );
if( acquired )
{
int temp = this.balance + amount;
this.balance = temp;
lock.unlock();
}
else
{}
}
}

36. Dead Lock
Lock lock1 = new ReentrantLock();
Lock lock2 = new ReentrantLock();
Thread #1 Thread #2
lock1.lock(); lock2.lock();
lock2.lock(); lock1.lock();
.... ...
lock2.unlock(); lock1.unlock();
lock1.unlock(); lock2.unlock();

37. Was es sonst noch gibt
• Semaphore
• erlauben einer festen Anzahl von Threads
das Betreten einer kritischen Region
• Connection Pools zu Datenbanken
• Conditions
• erlauben die Koordination zwischen
Threads
• typisch beim Producer / Consumer Muster

38. Methode
• Parallele Algorithmen
• Ohne Threads starten
• Laufzeit des Programms analysieren
• Kritische Bereiche verbessern durch parallele Verarbeitung
• Paralleler Ressourcenzugriff
• Mit gröbster Synchronisation beginnen
• Programm analysieren: warten Threads zu lange auf
Ressourcen?
• Kritische Bereiche verbessern durch feinere
Synchronisationsverfahren und Zeitüberschreitungen

39. Zusammenfassung und Ausblick
• Parallele Algorithmen
• Paralleler Ressourcenzugriff
• Synchronisationsmechanismen
• Race Conditions, Dead Locks
• Verteilte Systeme
• Map Reduce Algorithmen