Java Wspolbieznosc dla praktykow.pdf

Java. WspĀbieŃnoľě

Autor: ZespĀ autorw

TĀumaczenie: RafaĀ Joĺca

ISBN: 978-83-246-0921-5

TytuĀ oryginaĀu: Java Concurrency in Practice

Format: B5, stron: 376

Wydawnictwo Helion

ul. Koľciuszki 1c

44-100 Gliwice

tel. 032 230 98 63

e-mail: helion@helion.pl

Twrz bezpieczne i wydajne aplikacje wielowĴtkowe

Chcesz podnieľě wydajnoľě swoich aplikacji? Planujesz stworzenie systemu, ktry

bķdzie uruchamiany na maszynach wyposaŃonych w procesory wielordzeniowe?

A moŃe prbowaĀeľ juŃ tworzyě aplikacje wielowĴtkowe, ale zniechķciĀeľ siķ po

wielogodzinnych poszukiwaniach przyczyn bĀķdw, ktre pojawiajĴ siķ przy wysokich

obciĴŃeniach? Java niemal od poczĴtku swego istnienia jest wyposaŃona w mechanizmy

umoŃliwiajĴce tworzenie aplikacji wielowĴtkowych, lecz dopiero wersja 5. wniosĀa

zupeĀnie nowĴ jakoľě, dziķki wielu poprawkom zwiķkszajĴcym wydajnoľě maszyny

wirtualnej oraz dodatkowym klasom uĀatwiajĴcym osiĴganie lepszej wspĀbieŃnoľci.

W ksiĴŃce âJava. WspĀbieŃnoľě dla praktykwÒ znajdziesz wyczerpujĴcy opis metod

projektowania i tworzenia aplikacji wielowĴtkowych. Przeczytasz nie tylko o klasach,

ich dziaĀaniu i sposobach wykorzystania, ale rwnieŃ poznasz wzorce projektowe,

praktyki programistyczne i modele, dziķki ktrym programowanie wspĀbieŃne jest

Āatwiejsze. Znajdziesz tu praktyczne aspekty oraz przykĀady tworzenia pewnych,

skalowalnych i Āatwych w konserwacji aplikacji wspĀbieŃnych. Dowiesz siķ takŃe,

w jaki sposb testowaě aplikacje wielowĴtkowe, wynajdywaě w nich bĀķdy i usuwaě je.

Dziķki ksiĴŃce poznasz:

¤ MoŃliwoľci wykorzystania wĴtkw

¤ Podstawy stosowania wĴtkw

¤ WspĀdzielenie obiektw

¤ Struktura aplikacji wielowĴtkowych

¤ ZarzĴdzanie wĴtkami i zadaniami

¤ Zastosowania pul wĴtkw

¤ Optymalizowanie wydajnoľci

¤ Skalowalnoľě aplikacji wielowĴtkowych

¤ Testowanie aplikacji wspĀbieŃnych

¤ Model pamiķci Javy

¤ Tworzenie wĀasnych synchronizatorw

dla praktykw

Przedmowa ...................................................................................... 9

Rozdział 1. Wprowadzenie ................................................................................ 13

1.1. (Bardzo) krótka historia współbieżności .................................................................. 13

1.2. Zalety wątków .......................................................................................................... 15

1.3. Ryzyka związane z wątkami ..................................................................................... 18

1.4. Wątki są wszędzie .................................................................................................... 21

Część I Podstawy ..................................................................... 25

Rozdział 2. Wątki i bezpieczeństwo .................................................................. 27

2.1. Czym jest bezpieczeństwo wątkowe? ....................................................................... 29

2.2. Niepodzielność ......................................................................................................... 31

2.3. Blokady ..................................................................................................................... 35

2.4. Ochrona stanu za pomocą blokad ............................................................................. 39

2.5. Żywotność i wydajność ............................................................................................ 41

Rozdział 3. Współdzielenie obiektów ................................................................ 45

3.1. Widoczność .............................................................................................................. 45

3.2. Publikacja i ucieczka ................................................................................................ 51

3.3. Odosobnienie w wątku ............................................................................................. 54

3.4. Niezmienność ........................................................................................................... 58

3.5. Bezpieczna publikacja .............................................................................................. 61

Rozdział 4. Kompozycja obiektów ..................................................................... 67

4.1. Projektowanie klasy bezpiecznej wątkowo .............................................................. 67

4.2. Odosobnienie egzemplarza ....................................................................................... 71

4.3. Delegacja bezpieczeństwa wątkowego ..................................................................... 76

4.4. Dodawanie funkcjonalności do istniejących klas bezpiecznych wątkowo .............. 82

4.5. Dokumentowanie strategii synchronizacji ................................................................ 86

Rozdział 5. Bloki budowania aplikacji ............................................................... 89

5.1. Kolekcje synchronizowane ....................................................................................... 89

5.2. Kolekcje współbieżne ............................................................................................... 94

5.3. Kolejki blokujące oraz wzorzec producenta i konsumenta ...................................... 97

5.4. Metody blokujące i przerywane ............................................................................. 102

5.5. Synchronizatory ...................................................................................................... 104

5.6. Tworzenie wydajnego, skalowalnego bufora wyników ......................................... 112

Podsumowanie części I .................................................................................................. 117

Java. Współbieżność dla praktyków

Część II Struktura aplikacji współbieżnej .................................. 119

Rozdział 6. Wykonywanie zadań ..................................................................... 121

6.1. Wykonywanie zadań w wątkach ............................................................................ 121

6.2. Szkielet Executor .................................................................................................... 125

6.3. Znajdowanie sensownego zrównoleglenia ............................................................. 132

Podsumowanie ............................................................................................................... 141

Rozdział 7. Anulowanie i wyłączanie zadań ..................................................... 143

7.1. Anulowanie zadań .................................................................................................. 144

7.2. Zatrzymanie usługi wykorzystującej wątki ............................................................ 158

7.3. Obsługa nietypowego zakończenia wątku .............................................................. 167

7.4. Wyłączanie maszyny wirtualnej ............................................................................. 170

Podsumowanie ............................................................................................................... 173

Rozdział 8. Zastosowania pul wątków ............................................................ 175

8.1. Niejawnie splecione zadania i strategie wykonania ............................................... 175

8.2. Określanie rozmiaru puli wątków ........................................................................... 178

8.3. Konfiguracja klasy ThreadPoolExecutor ................................................................ 179

8.4. Rozszerzanie klasy ThreadPoolExecutor ............................................................... 187

8.5. Zrównoleglenie algorytmów rekurencyjnych ......................................................... 188

Podsumowanie ............................................................................................................... 195

Rozdział 9. Aplikacje z graficznym interfejsem użytkownika ............................. 197

9.1. Dlaczego graficzne interfejsy użytkownika są jednowątkowe? ............................. 197

9.2. Krótkie zadanie interfejsu graficznego ............................................................... 201

9.3. Długie czasowo zadania interfejsu graficznego ..................................................... 203

9.4. Współdzielone modele danych ............................................................................... 208

9.5. Inne postacie podsystemów jednowątkowych ...................................................... 209

Podsumowanie ............................................................................................................... 210

Część III Żywotność, wydajność i testowanie ............................ 211

Rozdział 10. Unikanie hazardu żywotności ........................................................ 213

10.1. Blokada wzajemna ................................................................................................ 213

10.2. Unikanie i diagnostyka blokad wzajemnych ........................................................ 223

Podsumowanie ............................................................................................................... 228

Rozdział 11. Wydajność i skalowalność ............................................................ 229

11.1. Myślenie na temat wydajności ............................................................................. 229

11.2. Prawo Amdahla .................................................................................................... 233

11.3. Koszta wprowadzane przez wątki ........................................................................ 237

11.4. Zmniejszanie rywalizacji o blokadę ..................................................................... 240

11.5. Przykład — porównanie wydajności obiektów Map ............................................ 250

11.6. Redukcja narzutu przełączania kontekstu ............................................................. 251

Podsumowanie ............................................................................................................... 253

Rozdział 12. Testowanie programów współbieżnych .......................................... 255

12.1. Testy sprawdzające poprawność .......................................................................... 256

12.2. Testowanie wydajności ......................................................................................... 268

12.3. Unikanie pomyłek w testach wydajności ............................................................. 273

12.4. Testy uzupełniające .............................................................................................. 278

Podsumowanie ............................................................................................................... 281

Spis treści

Część IV Techniki zaawansowane ............................................. 283

Rozdział 13. Blokady jawne ............................................................................. 285

13.1. Interfejs Lock i klasa ReentrantLock .................................................................... 285

13.2. Rozważania na temat wydajności ......................................................................... 290

13.3. Uczciwość ............................................................................................................. 291

13.4. Wybór między synchronized i ReentrantLock ..................................................... 293

13.5. Blokady odczyt-zapis ........................................................................................... 294

Podsumowanie ............................................................................................................... 297

Rozdział 14. Tworzenie własnych synchronizatorów .......................................... 299

14.1. Zarządzanie zależnością od stanu ......................................................................... 299

14.2. Wykorzystanie kolejek warunków ....................................................................... 306

14.3. Jawne obiekty warunków ..................................................................................... 314

14.4. Anatomia synchronizatora .................................................................................... 316

14.5. Klasa AbstractQueuedSynchronizer ........................................................................ 318

14.6. AQS w klasach synchronizatorów pakietu java.util.concurrent ........................... 321

Podsumowanie ............................................................................................................... 324

Rozdział 15. Zmienne niepodzielne i synchronizacja nieblokująca ...................... 325

15.1. Wady blokowania ................................................................................................. 326

15.2. Sprzętowa obsługa współbieżności ...................................................................... 327

15.3. Klasy zmiennych niepodzielnych ......................................................................... 331

15.4. Algorytmy nieblokujące ....................................................................................... 335

Podsumowanie ............................................................................................................... 342

Rozdział 16. Model pamięci Javy ...................................................................... 343

16.1. Czym jest model pamięci i dlaczego ma mnie interesować? ............................... 343

16.2. Publikacja ............................................................................................................. 350

16.3. Bezpieczeństwo inicjalizacji ................................................................................. 355

Podsumowanie ............................................................................................................... 356

Dodatki ...................................................................... 357

Dodatek A Adnotacje związane ze współbieżnością ........................................ 359

A.1. Adnotacje dla klas .................................................................................................. 359

A.2. Adnotacje pól i metod ............................................................................................ 360

Dodatek B Bibliografia .................................................................................. 361

Skorowidz .................................................................................... 365

Rozdział 3.

Na początku rozdziału 2. pojawiło się stwierdzenie, że poprawne programy współbieżne

muszą przede wszystkim właściwie zarządzać dostępem do współdzielonego, zmien-

nego stanu. Tamten rozdział dotyczył użycia synchronizacji do zabezpieczenia się przed

wieloma wątkami korzystającymi z tych samych danych w tym samym momencie.

Ten prezentuje techniki współdzielenia i publikacji obiektów, by były bezpieczne do

stosowania w wielu wątkach. Razem oba elementy stanowią podstawę tworzenia klas

bezpiecznych wątkowo i poprawnej konstrukcji współbieżnych aplikacji za pomocą

klas biblioteki java.util.concurrent .

W poprzednim rozdziale przedstawiliśmy, w jaki sposób bloki i metody synchronized

zapewniają niepodzielność operacji. Wielu osobom wydaje się, że te bloki dotyczą

tylko niepodzielności i oznaczania sekcji krytycznych. Synchronizacja ma także inny

istotny, choć subtelny, aspekt — widoczność pamięci . Chcemy nie tylko zapewnić,

by gdy jeden wątek modyfikuje stan obiektu, inne mu w tym nie przeszkadzały, ale

i to, by inne wątki rzeczywiście widziały dokonaną zmianę. Nie można tego osiągnąć

bez synchronizacji. Obiekty są bezpiecznie publikowane czy to za pomocą jawnej

synchronizacji, czy przez zastosowanie synchronizacji wybudowanej w klasy biblioteki.

3.1. Widoczność

Widoczność to subtelny temat, bo zadania, które mogą się nie udać, są mało intuicyjne.

W środowisku jednowątkowym, gdy zapisujemy wartość do zmiennej i później ją od-

czytujemy (w międzyczasie nie było innych zapisów), możemy się spodziewać otrzy-

mania tej samej wartości. Wydaje się to w miarę naturalne. Z tego względu początkowo

trudno zaakceptować, że w przypadku wielu odczytów i zapisów z wielu wątków

przedstawione założenie może nie zaistnieć . Ogólnie nie ma gwarancji, iż wątek

odczytujący zobaczy wartość zapisaną przez inny wątek w odpowiednim czasie, a nawet

w ogóle. Aby zapewnić widoczność zapisów do pamięci w różnych wątkach, należy

użyć synchronizacji.

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: