Autor: Praca zbiorowa

ISBN: 978-83-246-0921-5

Ilość stron: 376

Data wydania: 05/2007

Chcesz podnieść wydajność swoich aplikacji? Planujesz stworzenie systemu, który będzie uruchamiany na maszynach wyposażonych w procesory wielordzeniowe? A może próbowałeś już tworzyć aplikacje wielowątkowe, ale zniechęciłeś się po wielogodzinnych poszukiwaniach przyczyn błędów, które 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 praktyków" znajdziesz wyczerpujący opis metod projektowania i tworzenia aplikacji wielowątkowych. Przeczytasz nie tylko o klasach, ich działaniu i sposobach wykorzystania, ale również poznasz wzorce projektowe, praktyki programistyczne i modele, dzięki którym 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 sposób testować aplikacje wielowątkowe, wynajdywać w nich błędy i usuwać je.

Rozdziały:

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)

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)

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)