Współbieżność w języku Java

Transkrypt

Wstęp Wątki w Javie Zarządzanie wątkami Podsumowanie
Wojciech Rząsa
[email protected]
Katedra Informatyki i Automatyki, Politechnika Rzeszowska
16 kwietnia 2015
Wojciech Rząsa, KIiA PRz
1/47
Plan
1 Wstęp
2 Reprezentacja wątków w Javie
3 Zarządzanie wątkami
4 Podsumowanie
2/47
Plan
1 Wstęp
4 Podsumowanie
3/47
Oparta na wątkach
4/47
Oparta na wątkach
Prawdziwe wątki, które
4/47
Oparta na wątkach
mogą działać równolegle
4/47
Oparta na wątkach
mogą się wykonywać na różnych procesorach
4/47
Oparta na wątkach
nie są blokowane przez operacje IO innego wątku
4/47
Oparta na wątkach
Specyfika systemu operacyjnego
4/47
Oparta na wątkach
Proste zarządzanie
4/47
Oparta na wątkach
Proste zarządzanie
Prosta (?) komunikacja
4/47
Wątek
Niezależna ścieżka wykonywania danego programu
5/47
Wątek
Współdzielony kod programu
5/47
Wątek
Współdzielony segment danych
5/47
Wątek
Oddzielny wskaźnik na aktualnie wykonywaną instrukcję
5/47
Wątek
Oddzielny stos wywołań metod
5/47
Wątek
Oddzielna lista zmiennych lokalnych
5/47
Wątek
Lekkie, tanie, szybkie tworzenie
5/47
Wątek
Lekkie, tanie, szybkie tworzenie
Komunikacja bez dodatkowych mechanizmów (jak kolejki,
gniazda itp)
5/47
Program w Javie i wątki
Każdy program ma co najmniej jeden wątek użytkownika
(wątek główny)
6/47
(wątek główny)
Dodatkowe wątki maszyny wirtualnej (garbage collector)
6/47
(wątek główny)
Dodatkowe wątki maszyny wirtualnej (garbage collector)
Może dodatkowe wątki użytkownika
6/47
Sposób wykonywania wątków
Równoległy (w tym samym czasie)
Z przeplotem/podziałem czasu
7/47
Wady wątków
Problem współdzielenia zmiennych
8/47
Wady wątków
Problem synchronizacji
8/47
Wady wątków
Problem synchronizacji
Problem wykonania na wielu procesorach (w innych językach)
8/47
Plan
1 Wstęp
4 Podsumowanie
9/47
Reprezentacja wątku
Wątek jest obiektem
10/47
Implementuje metodę run
10/47
Dziedziczy po klasie Thread albo
10/47
Implementuje interfejs Runnable
10/47
Implementuje interfejs Runnable
Uruchamia się metodą start (nie run!)
10/47
Dziedziczenie po Thread
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Counter1 extends Thread {
public void run () {
for ( int i = 0; i < 10; i ++) {
System . out . println ( " Counter : " + i );
}
System . out . println ( " Counter finished . " );
}
public static void main ( String [] args ) {
Counter1 c = new Counter1 ();
System . out . println ( " Counter created . " );
c . start ();
System . out . println ( " Counter started . " );
System . out . println ( " Main finished . " );
}
}
Wątek jako klasa dziedzicząca po Thread
11/47
Dziedziczenie po Thread
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Counter created.
Counter started.
Main finished.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6
Counter: 7
Counter: 8
Counter: 9
Counter finished.
for ( int i = 0; i < 10; i ++) {
}
}
c . start ();
}
}
11/47
Implementacja Runnable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Counter2 implements Runnable {
for ( int i = 0; i < 10; i ++) {
}
}
Thread t = new Thread ( c );
t . start ();
}
}
Wątek jako klasa implementująca Runnable
12/47
Implementacja Runnable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Counter created.
Counter started.
Main finished.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6
Counter: 7
Counter: 8
Counter: 9
Counter finished.
class Counter2 implements Runnable {
for ( int i = 0; i < 10; i ++) {
}
}
t . start ();
}
}
Wątek jako klasa implementująca Runnable
12/47
extends Thread, czy implements Runnable?
13/47
Jednokrotne dziedziczenie
13/47
Jednokrotne dziedziczenie
extends Thread daje łatwiejszy dostęp do metod
obsługujących wątek
13/47
sleep join interrupt yield Nazwy Priorytety Daemony
Plan
1 Wstęp
sleep
join
interrupt
yield
Nazwy wątków
Priorytety
Daemony
Grupy wątków
Kończenie wątków
Współpraca i współzawodnictwo wątków
14/47
Obiekt wątku
Wątki są obiektami
15/47
Obiekt wątku
Zarządzanie poprzez wywoływanie na nich metod
15/47
Obiekt wątku
this w klasie, która dziedziczy po Thread
15/47
Obiekt wątku
this w klasie, która dziedziczy po Thread
W każdym miejscu: Thread.currentThread()
15/47
Uśpienie wątku
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class CounterSleep extends Thread {
for ( int i = 0; i < 10; i ++) {
try {
Thread . sleep (100); // 100 ms
} catch ( I n t e r r u p t e d E x c e p t i o n e ) {
System . out . println ( " Przerwano ! " );
}
}
}
CounterSleep c = new CounterSleep ();
c . start ();
}
}
16/47
Uśpienie wątku
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Counter created.
Counter started.
Main finished.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6
Counter: 7
Counter: 8
Counter: 9
Counter finished.
class CounterSleep extends Thread {
for ( int i = 0; i < 10; i ++) {
try {
Thread . sleep (100); // 100 ms
}
}
}
CounterSleep c = new CounterSleep ();
c . start ();
}
}
16/47
Uśpienie wątku (Runnable)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class CounterSleep2 implements Runnable {
for ( int i = 0; i < 10; i ++) {
try {
Thread . currentThread (). sleep (100); // 100 ms
}
}
}
Thread t = new Thread ( new CounterSleep2 ());
t . start ();
}
}
17/47
Uśpienie wątku (Runnable)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Counter created.
class CounterSleep2 implements Runnable {
Counter started.
Main finished.
for ( int i = 0; i < 10; i ++) {
Counter: 0
Counter: 1
try {
Counter: 2
Thread . currentThread (). sleep (100); // 100 ms
Counter: 3
Counter: 4
Counter: 5
}
Counter: 6
}
Counter: 7
Counter: 8
}
Counter: 9
Counter finished.
Thread t = new Thread ( new CounterSleep2 ());
t . start ();
}
}
17/47
Uśpienie wątku
Czas: milisekundy
18/47
Uśpienie wątku
Czas: milisekundy
Czas: milisekundy + nanosekundy
18/47
Uśpienie wątku
Czas: milisekundy
Problem z rozdzielczością zegara systemowego
18/47
Uśpienie wątku
Czas: milisekundy
Problem z rozdzielczością zegara systemowego
Uśpić można też wątek główny
18/47
Oczekiwanie na zakończenie wątku
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
for ( int i = 0; i < 10; i ++) {
}
}
c . start ();
}
}
19/47
Oczekiwanie na zakończenie wątku
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Counter created.
Counter started.
Main finished.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6
Counter: 7
Counter: 8
Counter: 9
Counter finished.
for ( int i = 0; i < 10; i ++) {
}
}
c . start ();
}
}
19/47
Oczekiwanie na zakończenie wątku – użycie join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class CounterJoin extends Thread {
for ( int i = 0; i < 10; i ++) {
}
}
CounterJoin c = new CounterJoin ();
c . start ();
try {
c . join (); // mo ż na poda ć z timeoutem
System . out . println ( " Przerwano oczekiwanie ! " );
}
}
}
Współbieżność
w językuliczJava
Główny wątek oczekuje na zakończenie
wątku
20/47
Oczekiwanie na zakończenie wątku – użycie join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Counter created.
Counter started.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6
Counter: 7
Counter: 8
Counter: 9
Counter finished.
Main finished.
class CounterJoin extends Thread {
for ( int i = 0; i < 10; i ++) {
}
}
CounterJoin c = new CounterJoin ();
c . start ();
try {
c . join (); // mo ż na poda ć z timeoutem
System . out . println ( " Przerwano oczekiwanie ! " );
}
}
}
Współbieżność
w językuliczJava
Główny wątek oczekuje na zakończenie
wątku
20/47
Przerwanie wątku (interrupt)
Wątek otrzymuje informację o przerwaniu
21/47
Wątek może zareagować, albo zignorować informację
21/47
Metody blokujące wątek zgłaszają InterruptedException
21/47
wait
21/47
wait
join
21/47
wait
join
sleep
21/47
wait
join
sleep
Sposób na zakończenie wątku przed czasem
21/47
Obsługa przerwania wątku
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class CounterInt1 extends Thread {
for ( int i = 0; i < 1000000; i ++) {
if ( interrupted ()) break ;
}
}
public static void main ( String [] args )
throws I n t e r r u p t e d E x c e p t i o n {
CounterInt1 c = new CounterInt1 ();
c . start ();
Thread . sleep (1);
c . interrupt ();
}
}
22/47
Obsługa przerwania wątku
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Counter created.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter started.
Main finished.
Counter finished.
class CounterInt1 extends Thread {
for ( int i = 0; i < 1000000; i ++) {
}
}
c . start ();
Thread . sleep (1);
c . interrupt ();
}
}
22/47
Obsługa przerwania wątku (Runnable)
1 class CounterInt2 implements Runnable {
2
3
for ( int i = 0; i < 1000000; i ++) {
4
5
if ( Thread . currentThread (). interrupted ())
6
break ;
7
}
8
9
}
10
11
12
13
14
15
16
17
t . start ();
18
Thread . sleep (1);
19
t . interrupt (); // na w ą tku !
20
21
22
23
}
24
} Rząsa, KIiA PRz
Wojciech
23/47
Obsługa przerwania wątku (Runnable)
1 class CounterInt2 implements Runnable {
2
3
for ( int i = 0; i < 1000000; i ++) {
4
5
if ( Thread . currentThread (). interrupted ())
6
break ;
7
}
8
9
}
10
11
12
13
14
15
16
17
t . start ();
18
Thread . sleep (1);
19
t . interrupt (); // na w ą tku !
20
21
22
23
}
24
} Rząsa, KIiA PRz
Wojciech
Counter created.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter started.
Main finished.
Counter finished.
23/47
Przerywanie wątku – uwagi
Metoda interrupt() ustawia flagę
24/47
Metoda interrupted() sprawdza i czyści flagę
24/47
Metoda isInterrupted() sprawdza nie czyści flagi!
24/47
Wygenerowanie InterruptedException czyści flagę
24/47
Wątek musi sam wspierać możliwość przerwania przez
interrupt
24/47
Wątek musi sam wspierać możliwość przerwania przez
interrupt
Obsługując wyjątek można na nowo ustawić flagę wywołując
(interrupt())
24/47
Przekazanie sterowania
Metoda yield
25/47
Metoda yield
Wątek przekazuje sterowanie do innego wątku
25/47
Metoda yield
Wątek przekazuje sterowanie do innego wątku
Skutki mogą być różne... ;-)
25/47
Użycie yield
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class CounterYield extends Thread {
for ( int i = 0; i < 1000000; i ++) {
if ( i % 2 == 0) yield ();
}
}
CounterYield c = new CounterYield ();
c . start ();
Thread . sleep (1);
c . interrupt ();
}
}
26/47
Użycie yield
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Counter created.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter started.
Counter finished.
Main finished.
for ( int i = 0; i < 1000000; i ++) {
if ( i % 2 == 0) yield ();
}
}
c . start ();
Thread . sleep (1);
c . interrupt ();
}
}
26/47
Użycie yield
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Counter created.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6
Counter: 7
Counter: 8
Counter: 9
Counter: 10
Counter: 11
Counter: 12
Counter started.
Counter finished.
Main finished.
for ( int i = 0; i < 1000000; i ++) {
if ( i % 2 == 0) yield ();
}
}
c . start ();
Thread . sleep (1);
c . interrupt ();
}
}
26/47
Użycie yield
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
for ( int i = 0; i < 1000000; i ++) {
if ( i % 2 == 0) yield ();
}
}
c . start ();
Thread . sleep (1);
c . interrupt ();
}
}
Counter created.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6
Counter: 7
Counter: 8
Counter: 9
Counter: 10
Counter: 11
Counter: 12
Counter: 13
Counter: 14
Counter: 15
Counter: 16
Counter: 17
Counter: 18
Counter: 19
Counter: 20
Counter: 21
Counter: 22
26/47
yield
Nie zapewnia determinizmu
Nie wymusza uruchomienia innego wątku
27/47
Nazwy wątków
Wątki mogą mieć nazwy
Istotne przy debugowaniu
28/47
Nazwy wątków
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class NamedCounter extends Thread {
public NamedCounter ( String name )
{ super ( name ); }
for ( int i = 0; i < 10; i ++) {
System . out . println ( " Counter " + getName ()+ " : " + i );
}
System . out . println ( " Counter " + getName ()+ " finished . " );
}
NamedCounter c1 = new NamedCounter ( " Licznik 1 " );
NamedCounter c2 = new NamedCounter ( " Licznik 2 " );
c1 . start ();
c2 . start ();
}
}
Counter
Licznik
Wojciech
Rząsa, KIiA
PRz
Wątek z nazwą
2: 0
29/47
Nazwy wątków – wyjście
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
2: 0
1: 0
2: 1
1: 1
2: 2
1: 2
2: 3
1: 3
2: 4
1: 4
2: 5
1: 5
2: 6
1: 6
2: 7
1: 7
2: 8
1: 8
2: 9
1: 9
2 finished.
1 finished.
30/47
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
2: 0
1: 0
2: 1
1: 1
2: 2
1: 2
2: 3
1: 3
2: 4
1: 4
2: 5
1: 5
2: 6
1: 6
2: 7
1: 7
2: 8
1: 8
2: 9
1: 9
2 finished.
1 finished.
Tutaj wątki się dokładnie
przeplatają
Nie musi tak być. . .
30/47
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
2: 0
1: 0
2: 1
1: 1
2: 2
1: 2
2: 3
1: 3
2: 4
1: 4
2: 5
1: 5
2: 6
1: 6
2: 7
1: 7
2: 8
1: 8
2: 9
1: 9
2 finished.
1 finished.
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Counter
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
Licznik
1: 0
1: 1
1: 2
1: 3
1: 4
1: 5
1: 6
1: 7
1: 8
2: 0
1: 9
2: 1
1 finished.
2: 2
2: 3
2: 4
2: 5
2: 6
2: 7
2: 8
2: 9
2 finished.
30/47
Nazwy wątków – Runnable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class NamedCounter2 implements Runnable {
for ( int i = 0; i < 10; i ++) {
System . out . println ( " Counter " +
Thread . currentThread (). getName ()+ " : " + i );
}
System . out . println ( " Counter " +
Thread . currentThread (). getName ()+ " finished . " );
}
Thread t1 =
new Thread ( new NamedCounter2 () , " Licznik 1 " );
Thread t2 =
new Thread ( new NamedCounter2 () , " Licznik 2 " );
t1 . start ();
t2 . start ();
}
}
Wątek z nazwą,
Runnable
31/47
Priorytety wątków
Można ustawiać piorytety dla wątków
32/47
Priorytety wątków
Pomiędzy Thread.MIN PRIORITY a Thread.MAX PRIORITY
32/47
Priorytety wątków
Domyślnie taki jak wątek tworzący, domyślnie
Thread.NORM PRIORITY
32/47
Priorytety wątków
Metoda setPriority(priorytet)
32/47
Priorytety wątków
Aktualnie:
32/47
Priorytety wątków
Aktualnie:
MIN PRIORITY 1
32/47
Priorytety wątków
Aktualnie:
MIN PRIORITY 1
NORM PRIORITY 5
32/47
Priorytety wątków
Aktualnie:
MIN PRIORITY 1
NORM PRIORITY 5
MAX PRIORITY 10
32/47
Daemony
Aplikacja kończy się gdy zakończą sie wszystkie wątki
użytkownika
Counter created.
Counter started.
Main finished.
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6
Counter: 7
Counter: 8
Counter: 9
Counter finished.
33/47
Daemony
użytkownika
Czasami niektóre wątki nie powinny blokować zakończenia
aplikacji
33/47
Daemony
użytkownika
aplikacji
Takie wątki to daemony
33/47
Daemony
użytkownika
aplikacji
działają w tle
33/47
Daemony
użytkownika
aplikacji
działają w tle
są potrzebne innym wątkom (rola usługowa)
33/47
Daemony
użytkownika
aplikacji
działają w tle
nie są potrzebne, gdy nie ma innych wątków
33/47
Daemony
użytkownika
aplikacji
działają w tle
Np. producent – konsument
33/47
Daemony
użytkownika
aplikacji
działają w tle
Każdy wątek można ustawić jako daemon
33/47
Daemony
użytkownika
aplikacji
działają w tle
Wywołanie setDaemon(true) na obiekcie wątku. . .
33/47
Daemony
użytkownika
aplikacji
działają w tle
Wywołanie setDaemon(true) na obiekcie wątku. . .
. . . zanim wątek zostanie wystartowany
33/47
Wątek Ticker – deamon
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Ticker extends Thread {
private long time ;
public Ticker ( long time ) {
super ( " Ticker " + time );
this . time = time ;
setDaemon ( true );
}
try {
while ( true ) {
sleep ( time );
System . out . println ( " == ======= ====< tick >========== " );
}
System . out . println ( " Ticker interruped ! " );
}
System . out . println ( " Ticker finished ! " );
}
}
Wątek daemona
34/47
Wątek LongCounter
1
2
3
4
5
6
7
8
9
10
class LongCounter extends Thread {
for ( int i = 0; i < 70000000; i ++) {
if ( i % 10000000 == 0) {
}
}
}
}
Wątek licznika
35/47
Wątek główny
1
2
3
4
5
6
7
8
9
10
11
public class TickerDemo {
Ticker ticker = new Ticker (10);
LongCounter counter = new LongCounter ();
ticker . start ();
counter . start ();
System . out . println ( " Main thread finished . " );
}
}
Wątek główny
36/47
Wyjście
Main thread finished.
Counter: 0
=============< tick >==========
=============< tick >==========
Counter: 10000000
=============< tick >==========
Counter: 20000000
=============< tick >==========
=============< tick >==========
Counter: 30000000
=============< tick >==========
Counter: 40000000
=============< tick >==========
=============< tick >==========
Counter: 50000000
=============< tick >==========
Counter: 60000000
=============< tick >==========
=============< tick >==========
Counter finished.
37/47
Wyjście
Counter: 0
=============< tick >==========
=============< tick >==========
Counter: 10000000
=============< tick >==========
Counter: 20000000
=============< tick >==========
=============< tick >==========
Counter: 30000000
=============< tick >==========
Counter: 40000000
=============< tick >==========
=============< tick >==========
Counter: 50000000
=============< tick >==========
Counter: 60000000
=============< tick >==========
=============< tick >==========
Counter finished.
Wątek główny zakończył się
niemal natychmiast
37/47
Wyjście
Counter: 0
=============< tick >==========
=============< tick >==========
Counter: 10000000
=============< tick >==========
Counter: 20000000
=============< tick >==========
=============< tick >==========
Counter: 30000000
=============< tick >==========
Counter: 40000000
=============< tick >==========
=============< tick >==========
Counter: 50000000
=============< tick >==========
Counter: 60000000
=============< tick >==========
=============< tick >==========
Counter finished.
niemal natychmiast
Wątek LongCounter zakończył
się poprawnie
37/47
Wyjście
Counter: 0
=============< tick >==========
=============< tick >==========
Counter: 10000000
=============< tick >==========
Counter: 20000000
=============< tick >==========
=============< tick >==========
Counter: 30000000
=============< tick >==========
Counter: 40000000
=============< tick >==========
=============< tick >==========
Counter: 50000000
=============< tick >==========
Counter: 60000000
=============< tick >==========
=============< tick >==========
Counter finished.
niemal natychmiast
Wątek LongCounter zakończył
się poprawnie
Program zakończył się pomimo
nieskończonej pętli wątku
Ticker
37/47
Grupy wątków
Wątki można łączyć w grupy (ThreadGroup)
38/47
Grupy wątków
Grupa może zawierać wątki oraz grupy wątków (drzewo)
38/47
Grupy wątków
Wątek może sprawdzić do jakiej grupy należy
(getThreadGroup)
38/47
Grupy wątków
(getThreadGroup)
Wątek może wylistować wątki ze swojej grupy (enumerate)
38/47
Grupy wątków
(getThreadGroup)
Można ustawić grupę jako deamon (setDaemon) (zostanie
automatycznie usunięta)
38/47
Grupy wątków
(getThreadGroup)
Można wykonywać interrupt na całej grupie wątków
38/47
Grupy wątków
(getThreadGroup)
Można wykonywać interrupt na całej grupie wątków
Można ograniczać priorytet dla całej grupy wątków
(setMaxPriority)
38/47
Kończenie wątków
Wątku nie da się „zabić”
39/47
Kończenie wątków
Problemy synchronizacji
39/47
Kończenie wątków
destroy never implemented, deadlock-prone
39/47
Kończenie wątków
stop deprecated, unsafe
39/47
Kończenie wątków
suspend deprecated, deadlock-prone
39/47
Kończenie wątków
resume deprecated
39/47
Kończenie wątków
resume deprecated
Wątek musi się zakończyć, albo
39/47
Kończenie wątków
resume deprecated
Wątek musi obsługiwać przerwanie, albo
39/47
Kończenie wątków
resume deprecated
Wątek musi być daemonem
39/47
Kończenie wątków
resume deprecated
Wątek musi być daemonem
Program w Javie oczywiście można „zabić”
39/47
Czy wątki współzawodniczą?
40/47
tak, w dostępie do zasobów
40/47
Wątki mogą współpracować
40/47
w rozwiązywaniu problemów
40/47
w rozwiązywaniu problemów
Współpraca wymaga komunikacji
40/47
Komunikacja pomiędzy wątkami
Wątki współdzielą zmienne
41/47
globalne
41/47
globalne
pola statyczne
41/47
globalne
pola statyczne
Współdzielą obiekty do których posiadają referencje
41/47
globalne
pola statyczne
Współdzielą obiekty do których posiadają referencje
Wspólne zmienne umożliwiają szybkie przekazywanie danych
41/47
Producent – konsument
Producent – jeden wątek
42/47
Konsument – drugi wątek
42/47
Producent zapisuje coś do współdzielonej zmiennej
42/47
Konsument odczytuje ze współdzielonej zmiennej
42/47
Wątki wykonują się z różną szybkością, w różnych momentach
42/47
Producent: czy można już zapisać?
42/47
Producent: czy można już zapisać?
Konsument: czy można już odczytać?
42/47
Producent – konsument, dłuższy bufor
43/47
43/47
Producent zapisuje coś do współdzielonej tablicy
43/47
Sprawdzenie czy tablica nie jest pełna
43/47
Zapisanie nowej danej
43/47
Przesunięcie indeksu tablicy
43/47
Konsument odczytuje ze współdzielonej tablicy
43/47
Sprawdzenie, czy tablica nie jest pusta
43/47
Odczytanie nowej danej
43/47
43/47
Wątki mogą się przeplatać w dowolnych momentach!
43/47
Synchronizacja
Operacje na wspólnych danych wymagają synchronizacji
44/47
Synchronizacja
Konieczne definiowanie operacji niepodzielnych
44/47
Synchronizacja
Oczekiwanie na zmianę
44/47
Synchronizacja
Oczekiwanie na zmianę
Powiadamianie o zmianach
44/47
Mechanizmy synchronizacji
Java zapewnia mechanizmy synchronizacji
45/47
Wbudowane w język – pewne, bezpieczne
45/47
Wbudowane w język – pewne, bezpieczne
Wygodne
45/47
Plan
1 Wstęp
4 Podsumowanie
46/47
Najczęściej realizowana za pomocą wątków
47/47
Wbudowana w język
47/47
Wbudowana w język
Efektywna
47/47
Wbudowana w język
Efektywna
Reprezentacja przy pomocy obiektów
47/47
Wbudowana w język
Efektywna
Metody do zarządzania wątkami
47/47
Wbudowana w język
Efektywna
Prawdziwe, równolegle działające wątki
47/47
Wbudowana w język
Efektywna
Zachowanie wątków zależy od systemu operacyjnego
47/47
Wbudowana w język
Efektywna
Brak determinizmu
47/47
Wbudowana w język
Efektywna
Brak determinizmu
Konieczna synchronizacja
47/47

Współbieżność w języku Java

Transkrypt

Podobne dokumenty

WH cs go - Grupo Quadrante

WH cs go - AURA KI МАГАЗИН инновационные технолоогии

Reportaż_Przybylski

ESWC 2011

Oswiadczenie II edycja Turnieju Gier

49 Obiekty komunikacyjne systemu KNX - typy, zasady

Poniedziałek 15.02.2016 r. Wtorek 16.02.2016 r. Środa 17.02.2016 r

Resetowanie zbiornika na zużyty atrament w drukarkach Epson

2010 FILM VIDEO FOTO - MTŁ ==- Międzynarodowe Targi Łódzkie