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

Szczegóły książki w Helionie
Tytuł oryginału: Java Concurrency in Practice
ISBN: 978-83-246-0921-5
Cena: 47 zł
Oprawa: miękka
Format: B5
Data wydania: 2007.05.29
Liczba stron: 376
Przykładowy rozdział: ftp://ftp.helion.pl/online/javwsp/javwsp-3.pdf
Kategoria: Java

Twórz bezpieczne i wydajne aplikacje wielowątkowe

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.

Dzięki książce poznasz:

  • Możliwości wykorzystania wątków
  • Podstawy stosowania wątków
  • Współdzielenie obiektów
  • Struktura aplikacji wielowątkowych
  • Zarządzanie wątkami i zadaniami
  • Zastosowania pul wątków
  • Optymalizowanie wydajności
  • Skalowalność aplikacji wielowątkowych
  • Testowanie aplikacji współbieżnych
  • Model pamięci Javy
  • Tworzenie własnych synchronizatorów

Java. Współbieżność dla praktyków -- spis treści

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)

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)

Skorowidz (365)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań