Synchronizacja w języku Java

Transkrypt

Wstęp Monitory Monitory w Javie Wykorzystanie Czytelnicy i pisarze
Synchronizacja wątków w języku Java
Wojciech Rząsa
[email protected]
Katedra Informatyki i Automatyki, Politechnika Rzeszowska
28 marca 2014
Wojciech Rząsa, KIiA PRz
1/48
Plan
1 Wstęp
2 Monitory
3 Monitory w Javie
4 Wykorzystanie
5 Czytelnicy i pisarze
2/48
Plan
1 Wstęp
2 Monitory
3 Monitory w Javie
4 Wykorzystanie
3/48
Synchronizacja
Operacje na wspólnych danych wymagają synchronizacji
4/48
Synchronizacja
Konieczne definiowanie operacji niepodzielnych
4/48
Synchronizacja
Oczekiwanie na zmianę
4/48
Synchronizacja
Oczekiwanie na zmianę
Powiadamianie o zmianach
4/48
Mechanizmy synchronizacji
Java zapewnia mechanizmy synchronizacji
5/48
Wbudowane w język – pewne, bezpieczne
5/48
Wygodne
5/48
Wygodne
Zapewniające
5/48
Wygodne
Zapewniające
Niepodzielność operacji
5/48
Wygodne
Zapewniające
Oczekiwanie, powiadamianie
5/48
Plan
1 Wstęp
2 Monitory
3 Monitory w Javie
4 Wykorzystanie
6/48
Monitory
Strukturalny mechanizm synchronizacji
7/48
Monitory
Łatwiejszy w użyciu niż semafory
7/48
Monitory
Mniejsze prawdopodobieństwo błędu
7/48
Monitory
Doskonale pasuje do programowania obiektowego
7/48
Monitory
Monitor
7/48
Monitory
Monitor
Grupuje dane (zmienne) i operacje
7/48
Monitory
Monitor
Zapewnia dostęp do operacji dla najwyżej jednego wątku
7/48
Monitory
Monitor
Program może zawierać wiele monitorów
7/48
Monitory
Monitor
Program może zawierać wiele monitorów
Synchronizacja na różnych monitorach jest niezależna
7/48
Zmienne warunkowe (condition)
Monitory mogą też zawierać zmienne warunkowe (condition)
8/48
Zmienne warunkowe pozwalają oczekiwać na zmianę warunku
8/48
Zmienne warunkowe pozwalają oczekiwać na zmianę warunku
Wątki oczekujące na zmiennej warunkowej można powiadomić
8/48
Monitory
Monitory zapewniają wykluczanie przy dostępie do operacji
9/48
Monitory
Zmienne monitorów są „prywatne”
9/48
Monitory
Monitory zapewniają możliwość pasywnego oczekiwania
9/48
Monitory
Oczekiwanie na zmiennych warunkowych
9/48
Monitory
Powiadamianie
9/48
Monitory
Powiadamianie
Mechanizm strukturalny (automatyczne uzyskanie i zwolnienie
blokad)
9/48
Monitory
Powiadamianie
Mechanizm strukturalny (automatyczne uzyskanie i zwolnienie
blokad)
Pojęcie monitora doskonale pasuje do pojęcia obiektu
9/48
Plan
1 Wstęp
2 Monitory
3 Monitory w Javie
4 Wykorzystanie
10/48
Monitory w Javie
Związane z każdym obiektem (Object)
11/48
Monitory w Javie
Uboższe (prostsze?) niż teoretyczne
11/48
Monitory w Javie
Konkretnie
11/48
Monitory w Javie
Konkretnie
bloki i metody synchronized
11/48
Monitory w Javie
Konkretnie
metody wait, notify notifyAll
11/48
Monitory w Javie
Konkretnie
synchronized dla konkretnego obiektu – wykluczanie
11/48
Monitory w Javie
Konkretnie
Tylko jedna zmienna condition
11/48
Monitory w Javie
Konkretnie
Brak możliwości oczekiwania na konkretny warunek
11/48
Monitory w Javie
Konkretnie
Brak możliwości oczekiwania na konkretny warunek
Monitory różnych obiektów są niezależne
11/48
Plan
1 Wstęp
2 Monitory
3 Monitory w Javie
4 Wykorzystanie
12/48
Producent – konsument
Producent wytwarza produkt
13/48
Konsument konsumuje produkt
13/48
Każdy produkt ma być dokładnie raz skonsumowany
13/48
Każdy produkt ma być dokładnie raz skonsumowany
Może być wielu producentów i konsumentów
13/48
Producent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Producent extends Thread {
private Bufor bufor ;
Producent ( Bufor b , String name ) {
super ( name );
this . bufor = b ;
setDaemon ( true );
}
public void run () {
int produkt = 0;
while ( true ) {
produkt ++;
try {
sleep (( int )( Math . random ()*100)+100);
} 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 ( " sleep przerwane ! " );
}
System . out . println ( getName ()+ " wyprodukowa ł : " + produkt );
bufor . put ( produkt );
}
}
}
14/48
Konsument
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Konsument extends Thread {
private Bufor bufor ;
Konsument ( Bufor b , String name ) {
super ( name );
this . bufor = b ;
}
for ( int i = 0; i < 10; i ++) {
try {
sleep (( int )( Math . random ()*100)+100);
} 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 ( " sleep przerwane ! " );
}
int produkt = bufor . get ();
System . out . println ( getName ()+ " skonsumowa ł : " + produkt );
}
}
}
Implementacja konsumenta
15/48
Interfejs Bufora
1
2
3
4
public interface Bufor {
public void put ( int p );
public int get ();
}
Interfejs bufora danych
16/48
Uruchomienie
1
2
3
4
5
6
7
public class ProdKons {
public static void main ( String [] args ) {
Bufor bufor = new BuforBasic ();
( new Producent ( bufor , " Producent " )). start ();
( new Konsument ( bufor , " Konsument " )). start ();
}
}
Wykorzystanie producenta i konsumenta
17/48
Bufor bez synchronizacji (niepoprawny!)
1
2
3
4
5
6
7
8
9
10
11
public class BuforBasic implements Bufor {
private int product ;
public void put ( int p ) {
product = p ;
}
public int get () {
return product ;
}
}
Niepoprawna implementacja bufora (bez synchronizacji)
18/48
Wynik braku synchronizacji
Producent
Konsument
Producent
Konsument
Konsument
Producent
Konsument
Producent
Konsument
Producent
Konsument
Producent
Konsument
Producent
Konsument
Producent
Konsument
Konsument
wyprodukował: 1
skonsumował: 1
wyprodukował: 2
skonsumował: 2
skonsumował: 2
wyprodukował: 3
skonsumował: 3
wyprodukował: 4
skonsumował: 4
wyprodukował: 5
skonsumował: 5
wyprodukował: 6
skonsumował: 6
wyprodukował: 7
skonsumował: 7
wyprodukował: 8
skonsumował: 8
skonsumował: 8
19/48
Miejsce w buforze
Sprawdzenie, czy bufor
nie jest pełny (producent)
jest niepusty (konsument)
20/48
Bufor z flagą (nadal niepoprawny!)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class BuforFlag implements Bufor {
private boolean pusty = true ;
product = p ;
pusty = false ;
}
public int get () {
pusty = true ;
return product ;
}
}
Niepoprawna implementacja bufora (z flagą pełny/pusty)
21/48
Bufor z flagą (nadal niepoprawny!)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class BuforFlag implements Bufor {
product = p ;
pusty = false ;
}
public int get () {
pusty = true ;
return product ;
}
}
Niepoprawna implementacja bufora (z flagą pełny/pusty)
Wiarygodne wykorzystanie flagi wymaga niepodzielności
operacji!
21/48
Metody synchronized
22/48
Metody synchronized
Tylko jedna metoda synchronized dla obiektu w tym samym
momencie
22/48
Metody synchronized
Tylko jedna metoda synchronized dla obiektu w tym samym
momencie
Definiują sekcję krytyczną dla obiektu
22/48
Bufor z met. synchronizowanymi (nadal niepoprawny!)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class BuforSync {
synchronized public void put ( int p ) {
product = p ;
pusty = false ;
}
synchronized public int get () {
pusty = true ;
return product ;
}
}
Niepoprawna implementacja bufora
23/48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
product = p ;
pusty = false ;
}
pusty = true ;
return product ;
}
}
Nadal nie sprawdzamy stanu bufora
23/48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
product = p ;
pusty = false ;
}
pusty = true ;
return product ;
}
}
Nadal nie sprawdzamy stanu bufora
A co zrobić jeśli stan bufora jest nieodpowiedni?
23/48
Bufor ze sprawdzaniem warunków i synchronizacją
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class BuforWarunki implements Bufor {
while (! pusty ) {
try { wait (); }
catch ( I n t e r r u p t e d E x c e p t i o n e ) {}
}
product = p ;
pusty = false ;
notify ();
}
while ( pusty ) {
try { wait (); }
}
pusty = true ;
notify ();
return product ;
}
}
24/48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
while (! pusty ) {
try { wait (); }
}
product = p ;
pusty = false ;
notify ();
}
while ( pusty ) {
try { wait (); }
}
pusty = true ;
notify ();
return product ;
}
}
Co robi
notify()?
Synchronizacjawarunków
wątków w języku Java
Bufor z synchronizacją i sprawdzaniem
25/48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
while (! pusty ) {
try { wait (); }
}
product = p ;
pusty = false ;
notify ();
}
while ( pusty ) {
try { wait (); }
}
pusty = true ;
notify ();
return product ;
}
}
Co robi
notify()?
A jeśli
będzie
wielu?
Synchronizacjawarunków
wątków w języku Java
Bufor z synchronizacją i sprawdzaniem
25/48
Bufor dla wielu producentów i konsumentów
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class BuforMulti implements Bufor {
while (! pusty ) {
try { wait (); }
}
product = p ;
pusty = false ;
notifyAll ();
}
while ( pusty ) {
try { wait (); }
}
pusty = true ;
notifyAll ();
return product ;
}
}
26/48
Wielu producentów i konsumentów
1
2
3
4
5
6
7
8
9
public class ProdKonsMulti {
public static void main ( String [] args ) {
Bufor bufor = new BuforMulti ();
for ( int i = 1; i < 10; i ++) {
( new Producent ( bufor , " Producent " + i )). start ();
( new Konsument ( bufor , " Konsument " + i )). start ();
}
}
}
Wielu producentów i konsumentów
27/48
Metody notify i notifyAll
Można jedynie obudzić wszystkich, albo którykolwiek
Problem efektywności
Brak kolejki związanej z wait i notify
Mogą być wywołane tylko wewnątrz bloku synchronized
28/48
Metoda wait
Może być wywołane tylko wewnątrz bloku synchronized
29/48
Metoda wait
Powoduje zwolnienie sekcji krytycznej
29/48
Metoda wait
Wiele wątków może czekać na wait (i konkurować ze sobą)
29/48
Metoda wait
Możliwe tzw. fałszywe wybudzenia
29/48
Metoda wait
Obsługa InterruptedException
29/48
Metoda wait
Pozwala uniknąć aktywnego oczekiwania
1
while (! pusty ) {}
Pętla aktywnego oczekiwania
29/48
Metoda wait
Pozwala uniknąć aktywnego oczekiwania
1
while (! pusty ) {}
Pętla aktywnego oczekiwania
1
2
3
while (! pusty ) {
Thread . sleep (10);
}
Pętla aktywnego oczekiwania ze sleep
29/48
Metody i bloki synchronized
Metody oznaczone jako synchronized
30/48
Bloki synchronized wywołane na obiekcie
1
2
3
synchronized ( obiekt ) {
// tu instrukcje
}
Blok synchronized
30/48
1
2
3
// tu instrukcje
}
Blok synchronized
Sekcja krytyczna
Wszystkie metody synchronized danego obiektu
Wszystkie bloki synchronized wywołane dla obiektu
30/48
1
2
3
// tu instrukcje
}
Blok synchronized
Sekcja krytyczna
Wszystkie metody synchronized danego obiektu
Wszystkie bloki synchronized wywołane dla obiektu
Statyczne metody synchronized
30/48
Synchronizacja w Javie
Sekcje krytyczne: synchronized
Pasywne oczekiwanie: wait
Powiadamianie: notify i notifyAll
31/48
Brak możliwości obudzenia wybranych wątków
Brak możliwości czekania na różne warunki wewnątrz jednej
sekcji synchronized
Brak kolejek (wątki współzawodniczą)
31/48
Plan
1 Wstęp
2 Monitory
3 Monitory w Javie
4 Wykorzystanie
32/48
Czytelnicy i pisarze
Czytelnia
Czytelnicy mogą czytać wspólnie
Pisarz wymaga dostępu na wyłączność
Typowy problem informatyczny
33/48
Czytelnik
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Czytelnik extends Thread {
private Czytelnia c ;
Czytelnik ( String name , Czytelnia c ) {
super ( name ); this . c = c ;
}
for ( int i = 0; i < 10; i ++) {
System . out . println ( getName () + " chce czyta ć . " );
c . p o c z a t e k C z y t a n i a (); // protok ó ł wst ę pny
try {
System . out . println ( getName () + " czyta . " );
Thread . sleep (( int )( Math . random ()*1000)); // czytanie
} 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 ( getName () + " sko ń czy ł czyta ć . " );
c . koniecCz ytania (); // protok ó ł ko ń cowy
try {
Thread . sleep (( int )( Math . random ()*1000));
}
}
}
34/48
Pisarz
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Pisarz extends Thread {
private Czytelnia c ;
Pisarz ( String name , Czytelnia c ) {
super ( name ); this . c = c ; setDaemon ( true );
}
for ( int i = 0; i < 10; i ++) {
System . out . println ( getName () + " chce pisa ć . " );
c . p oc za te k Pi sa ni a (); // protok ó ł wst ę pny
try {
System . out . println ( getName () + " pisze . " );
Thread . sleep (( int )( Math . random ()*1000)); // pisanie
System . out . println ( getName () + " sko ń czy ł pisa ć . " );
c . koniecPisania (); // protok ó ł ko ń cowy
try {
Thread . sleep (( int )( Math . random ()*1000));
}
}
}
35/48
Czytelnia
1
2
3
4
5
6
public interface Czytelnia {
public void p o c z a t e k C z y t a n i a ();
public void ko niecCzy tania ();
public void po cz a te kP i sa ni a ();
public void koniecPisania ();
}
Interfejs czytelni
36/48
Uruchomienie wątków
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class CzytPis {
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 {
Czytelnia c = new CzytelniaOK ();
for ( int i = 0; i < 10; i ++) {
new Czytelnik ( " Czytelnik " + i , c ). start ();
}
for ( int i = 0; i < 10; i ++) {
new Pisarz ( " Pisarz " + i , c ). start ();
}
}
}
Uruchomienie wątków
37/48
Czytelnia ver. 1 (początek)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class C z y t e l n i a C z y t e l n i k o w implements Czytelnia {
private int czytelnikow = 0;
private int pisarzy = 0;
synchronized public void p o c z a t e k C z y t a n i a () {
while ( pisarzy > 0) {
try { wait (); }
catch ( I n t e r r u p t e d E x c e p t i o n e ){}
}
czytelnikow ++;
}
synchronized public void ko niecCzy tania () {
czytelnikow - -;
notifyAll ();
}
/* ... */
Czytelnia (początek)
38/48
Czytelnia ver. 1 (koniec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* ... */
synchronized public void po c za te kP i sa ni a () {
while ( czytelnikow > 0 || pisarzy > 0) {
try { wait (); }
}
pisarzy ++;
}
synchronized public void koniecPisania () {
pisarzy - -;
notifyAll ();
}
}
Czytelnia (koniec)
39/48
Uwagi
Faworyzuje czytelników
Może zagłodzić pisarzy
40/48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class C z y t e l n i a P i s a r z y implements Czytelnia {
private int pisarzy_czeka = 0;
while ( pisarzy > 0 || pisarzy_czeka > 0) {
try { wait (); }
}
czytelnikow ++;
}
czytelnikow - -;
notifyAll ();
}
/* ... */
Czytelnia (początek)
41/48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* ... */
pisarzy_czeka ++;
try { wait (); }
}
pisarzy_czeka - -;
pisarzy ++;
}
pisarzy - -;
notifyAll ();
}
}
Czytelnia (koniec)
42/48
Uwagi
Faworyzuje pisarzy
Może zagłodzić czytelników
43/48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class CzytelniaOK implements Czytelnia {
private int pisarzy_czeka = 0;
private boolean k o l e j _ n a _ p i s a r z y = false ;
while ( pisarzy > 0 || ( pisarzy_czeka > 0 && k o l e j _ n a _ p i s a r z y ))
try { wait (); }
}
k o l e j _ n a _ p i s a rz y = true ;
czytelnikow ++;
}
czytelnikow - -;
notifyAll ();
}
/* ... */
Czytelnia
(początek)
44/48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* ... */
pisarzy_czeka ++;
try { wait (); }
}
pisarzy_czeka - -;
pisarzy ++;
}
k o l e j _ n a _ p i s a rz y = false ;
pisarzy - -;
notifyAll ();
}
}
Czytelnia (koniec)
45/48
Rozwiązanie poprawne
Daje szansę wejścia pisarzom
Daje szansę wejścia czytelnikom
Nie blokuje czytelników, gdy nie ma pisarzy
Nie blokuje pisarzy, gdy nie ma czytelników
46/48
Implementacja w Javie
Istnieje coś podobnego do monitora
„Monitor” w Javie nie może mieć wielu zmiennych condition
Nie można budzić osobno czytelników, osobno pisarzy
47/48
Warto zobaczyć: java.util.concurrent – inne narzędzia
wspierające współbieżność
48/48

Synchronizacja w języku Java

Transkrypt

Podobne dokumenty

panoramiczne monitory lcd

LEKCJA

Szkolenia IT • Kursy Komputerowe • Szkolenia

SMT-171P - Profesjonalne monitory LCD do systemów

SMT-190P - Profesjonalne monitory LCD do systemów

ściągnij PDF z prezentacją rozwiązania monitorów sieciowych LG

Testy - budowa komputera

Trochę szersza rzeczywistość – jak zwiększyć pole widzenia w grach

Yamaha Hs 5 White

Kolumny Amphion Argon 1 - test w HiFi i Muzyka 0,3 Mb