Android. Aplikacje wielowątkowe. Techniki przetwarzania

Tytuł oryginału: Efficient Android Threading: Asynchronous processing techniques for Android applications
Tłumaczenie: Lech Lachowski
ISBN: 978-83-246-9614-7
Data wydania: 2015-02-24
Format: 168x237
Stron: 248

Wykorzystaj w pełni potencjał wątków!

Jeżeli chcesz tworzyć aplikacje dostarczające użytkownikom doskonałych wrażeń, jeżeli chcesz wykonywać skomplikowane zadania szybciej lub po prostu musisz jednocześnie wykonywać różne działania — naucz się korzystać z wątków. Tworzenie programów wielowątkowych jest trudne, ale opanowanie tej sztuki pozwoli Ci osiągnąć wymierne korzyści!

Ta książka w całości poświęcona jest korzystaniu z wątków na platformie Android. Dzięki niej poznasz przeróżne sposoby asynchronicznego przetwarzania oraz ich zalety i wady. Jednak na samym początku zapoznasz się z podstawowymi informacjami dotyczącymi wielowątkowości w języku Java. Dowiesz się, w jaki sposób wątki komunikują się ze sobą i synchronizują dostęp do zasobów oraz jak nimi zarządzać. Kolejne rozdziały zawierają sporą dawkę wiedzy na temat różnych technik asynchronicznych. Zapoznanie się z ich treścią ułatwi Ci wybór techniki, która spełni Twoje wymagania, gdy sam zabierzesz się za tworzenie aplikacji wielowątkowej. Książka ta jest obowiązkową lekturą dla programistów chcących w pełni wykorzystać możliwości platformy Android.

• Podstawy wielowątkowości w Javie i systemie Android.
• Komunikacja wątków w obrębie procesu i pomiędzy procesami.
• Zastosowanie strategii redukowania ryzyka powstawania wycieków pamięci.
• Zarządzanie cyklem życia wątku podstawowego.
• Sekwencyjne uruchamianie zadań w wątku tła za pomocą klasy HandlerThread.
• Używanie frameworku wykonawcy Javy do kontrolowania i anulowania wątków.
• Obsługa wykonywania zadań w tle za pomocą klas AsyncTask oraz IntentService.
• Uzyskiwanie dostępu do dostawców treści za pomocą klasy AsyncQueryHandler.
• Używanie ładowarek do aktualizowania interfejsu użytkownika nowymi danymi.

Przewodnik po świecie wątków platformy Android!

Spis treści

Przedmowa (11) 1. Komponenty systemu Android oraz potrzeba przetwarzania wieloprocesorowego (15)

• Stos programowy systemu Android (15)
• Architektura aplikacji (16)
  • Aplikacja (17)
  • Komponenty (17)
• Wykonywanie aplikacji (19)
  • Procesy systemu Linux (19)
  • Cykl życia (20)
• Strukturyzacja aplikacji w celu zwiększenia wydajności (23)
  • Tworzenie aplikacji responsywnych za pomocą wątków (23)
• Podsumowanie (25)

CZĘŚĆ I. PODSTAWY (27) 2. Wielowątkowość w Javie (29)

• Podstawy wątków (29)
  • Wykonywanie (29)
  • Aplikacja jednowątkowa (30)
  • Aplikacja wielowątkowa (31)
• Bezpieczeństwo wątków (33)
  • Blokada wewnętrzna i monitor Javy (34)
  • Synchronizowanie dostępu do zasobów współdzielonych (35)
  • Przykład: konsument i producent (37)
• Strategie wykonywania zadań (38)
  • Model wykonywania współbieżnego (39)
• Podsumowanie (40)

3. Wątki w systemie Android (41)

• Wątki aplikacji w systemie Android (41)
  • Wątki interfejsu użytkownika (41)
  • Wątki wiązania (42)
  • Wątki w tle (42)
• Proces i wątki systemu Linux (43)
  • Szeregowanie (45)
• Podsumowanie (48)

4. Komunikacja wątków (49)

• Potoki (49)
  • Podstawowe zastosowanie potoków (50)
  • Przykład: przetwarzanie tekstu w wątku roboczym (51)
• Pamięć współdzielona (53)
  • Sygnalizacja (54)
• Interfejs BlockingQueue (55)
• Przesyłanie komunikatów w systemie Android (56)
  • Przykład: podstawowe przesyłanie komunikatów (57)
  • Klasy stosowane w przesyłaniu komunikatów (59)
  • Komunikaty (63)
  • Looper (66)
  • Handler (67)
  • Usuwanie komunikatów z kolejki (75)
  • Obserwowanie kolejki komunikatów (76)
• Komunikacja z wątkiem interfejsu użytkownika (79)
• Podsumowanie (80)

5. Komunikacja między procesami (81)

• RPC systemu Android (81)
  • Binder (82)
• Język AIDL (83)
  • Synchroniczne wywołanie RPC (84)
  • Asynchroniczne wywołanie RPC (86)
• Przekazywanie komunikatów za pomocą obiektu Binder (88)
  • Komunikacja jednokierunkowa (89)
  • Komunikacja dwukierunkowa (91)
• Podsumowanie (92)

6. Zarządzanie pamięcią (93)

• Odzyskiwanie pamięci (93)
• Wycieki pamięci związane z wątkiem (95)
  • Wykonywanie wątku (96)
  • Komunikacja wątków (101)
• Unikanie wycieków pamięci (103)
  • Korzystanie ze statycznych klas wewnętrznych (104)
  • Korzystanie ze słabych referencji (104)
  • Zatrzymywanie wykonywania wątku roboczego (105)
  • Zachowanie wątków roboczych (105)
  • Czyszczenie kolejki komunikatów (105)
• Podsumowanie (106)

CZĘŚĆ II. TECHNIKI ASYNCHRONICZNE (107) 7. Zarządzanie cyklem życia wątku podstawowego (109)

• Podstawy (109)
  • Cykl życia (109)
  • Przerwania (110)
  • Wyjątki nieprzechwycone (112)
• Zarządzanie wątkami (113)
  • Definiowanie i uruchamianie (113)
  • Retencja (115)
• Podsumowanie (120)

8. Klasa HandlerThread: wysokopoziomowy mechanizm kolejkowania (121)

• Podstawy (121)
• Cykl życia (123)
• Przypadki użycia (124)
  • Powtarzające się wykonywanie zadania (124)
  • Zadania powiązane (125)
  • Łańcuchowanie zadań (127)
  • Warunkowe wstawianie zadania (129)
• Podsumowanie (130)

9. Kontrola wykonywania wątku za pomocą frameworku wykonawcy (131)

• Interfejs Executor (131)
• Pule wątków (133)
  • Predefiniowane pule wątków (134)
  • Niestandardowe pule wątków (135)
  • Projektowanie puli wątków (136)
  • Cykl życia (139)
  • Zamykanie puli wątków (140)
  • Przypadki użycia i pułapki pul wątków (141)
• Zarządzanie zadaniami (143)
  • Reprezentacja zadania (143)
  • Zatwierdzanie zadań (144)
  • Odrzucanie zadań (147)
• Klasa ExecutorCompletionService (148)
• Podsumowanie (150)

10. Wiązanie zadania w tle z wątkiem interfejsu użytkownika za pomocą klasy AsyncTask (151)

• Podstawy (151)
  • Tworzenie i uruchamianie (154)
  • Anulowanie (154)
  • Stany (155)
• Implementacja klasy AsyncTask (156)
  • Przykład: pobieranie obrazów (157)
• Wykonywanie zadania w tle (160)
  • Wykonywanie globalne dla aplikacji (161)
  • Wykonywanie zadań w różnych wersjach platformy (162)
  • Wykonywanie niestandardowe (164)
• Alternatywy dla klasy AsyncTask (165)
  • Trywialne implementacje klasy AsyncTask (165)
  • Zadania w tle wymagające instancji Looper (166)
  • Usługa lokalna (166)
  • Korzystanie z metody execute(Runnable) (167)
• Podsumowanie (167)

11. Usługi (169)

• Dlaczego warto wykorzystać komponent Service do wykonywania asynchronicznego? (169)
• Usługi lokalne, zdalne i globalne (171)
• Tworzenie i wykonywanie (172)
• Cykl życia (173)
• Usługa uruchamiana (174)
  • Implementacja metody onStartCommand (175)
  • Opcje ponownego uruchamiania (176)
  • Usługa kontrolowana przez użytkownika (178)
  • Usługa kontrolowana przez zadanie (181)
• Usługa wiązana (183)
  • Wiązanie lokalne (184)
• Wybór techniki asynchronicznej (187)
• Podsumowanie (188)

12. Klasa IntentService (189)

• Podstawy (189)
• Dobre sposoby wykorzystania klasy IntentService (190)
  • Zadania uporządkowane sekwencyjnie (191)
  • Wykonywanie asynchroniczne w komponencie BroadcastReceiver (193)
• Porównanie klas IntentService oraz Service (196)
• Podsumowanie (196)

13. Uzyskiwanie dostępu do klasy ContentProvider za pomocą klasy AsyncQueryHandler (197)

• Krótkie wprowadzenie do klasy ContentProvider (197)
• Uzasadnienie dla przetwarzania w tle klasy ContentProvider (199)
• Korzystanie z klasy AsyncQueryHandler (200)
  • Przykład: rozszerzanie listy kontaktów (201)
  • Klasa AsyncQueryHandler (204)
  • Ograniczenia (205)
• Podsumowanie (205)

14. Automatyczne wykonywanie w tle za pomocą ładowarek (207)

• Framework ładowarek (208)
  • Klasa LoaderManager (209)
  • Interfejsy LoaderCallbacks (211)
  • Klasa AsyncTaskLoader (213)
• Bezproblemowe ładowanie danych za pomocą ładowarki CursorLoader (213)
  • Korzystanie z ładowarki CursorLoader (214)
  • Przykład: lista kontaktów (214)
  • Dodawanie obsługi operacji CRUD (215)
• Implementowanie niestandardowych ładowarek (219)
  • Cykl życia ładowarki (219)
  • Ładowanie w tle (220)
  • Zarządzanie treścią (222)
  • Dostarczanie zbuforowanych rezultatów (223)
  • Przykład: niestandardowa ładowarka plików (223)
  • Obsługa wielu ładowarek (226)
• Podsumowanie (227)

15. Podsumowanie: wybór techniki asynchronicznej (229)

• Zachowanie prostoty (230)
• Zarządzanie zasobami i wątkami (230)
• Wymiana komunikatów w celu uzyskania responsywności (231)
• Unikanie nieoczekiwanego zakończenia zadania (231)
• Łatwy dostęp do klasy ContentProvider (232)

A. Bibliografia (235) Skorowidz (237)