Android. Aplikacje wielowątkowe. Techniki przetwarzania

Table of contents

1. Android Aplikacje wielowątkowe Techniki przetwarzania
2. Dedykacja
3. Przedmowa
   1. Czytelnicy
   2. Zawartość książki
   3. Konwencje użyte w tej książce
   4. Korzystanie z przykładów kodu
   5. Podziękowania
4. 1. Komponenty systemu Android oraz potrzeba przetwarzania wieloprocesorowego
   1. Stos programowy systemu Android
   2. Architektura aplikacji
      1. Aplikacja
      2. Komponenty
         1. Komponent Activity
         2. Komponent Service
         3. Komponent ContentProvider
         4. Komponent BroadcastReceiver
   3. Wykonywanie aplikacji
      1. Procesy systemu Linux
      2. Cykl życia
         1. Uruchamianie aplikacji
         2. Kończenie działania aplikacji
   4. Strukturyzacja aplikacji w celu zwiększenia wydajności
      1. Tworzenie aplikacji responsywnych za pomocą wątków
   5. Podsumowanie
5. I. Podstawy
   1. 2. Wielowątkowość w Javie
      1. Podstawy wątków
         1. Wykonywanie
         2. Aplikacja jednowątkowa
         3. Aplikacja wielowątkowa
            1. Zwiększone zużycie zasobów
            2. Zwiększona złożoność
            3. Niespójność danych
      2. Bezpieczeństwo wątków
         1. Blokada wewnętrzna i monitor Javy
         2. Synchronizowanie dostępu do zasobów współdzielonych
            1. Korzystanie z blokady wewnętrznej
            2. Korzystanie z jawnego mechanizmu blokowania
         3. Przykład: konsument i producent
      3. Strategie wykonywania zadań
         1. Model wykonywania współbieżnego
      4. Podsumowanie
   2. 3. Wątki w systemie Android
      1. Wątki aplikacji w systemie Android
         1. Wątki interfejsu użytkownika
         2. Wątki wiązania
         3. Wątki w tle
      2. Proces i wątki systemu Linux
         1. Szeregowanie
            1. Priorytet
            2. Grupy kontrolne
      3. Podsumowanie
   3. 4. Komunikacja wątków
      1. Potoki
         1. Podstawowe zastosowanie potoków
         2. Przykład: przetwarzanie tekstu w wątku roboczym
      2. Pamięć współdzielona
         1. Sygnalizacja
      3. Interfejs BlockingQueue
      4. Przesyłanie komunikatów w systemie Android
         1. Przykład: podstawowe przesyłanie komunikatów
         2. Klasy stosowane w przesyłaniu komunikatów
            1. Klasa MessageQueue
            2. Klasa MessageQueue.IdleHandler
            3. Przykład: użycie interfejsu IdleHandler do zakończenia niewykorzystywanego wątku
         3. Komunikaty
            1. Zainicjowany
            2. Oczekujący
            3. Wysłany
            4. Odzyskany
         4. Looper
            1. Zakończenie obiektu Looper
            2. Looper wątku interfejsu użytkownika
         5. Handler
            1. Konfiguracja
            2. Tworzenie komunikatu
            3. Wstawianie komunikatów
            4. Przykład: dwukierunkowe przesyłanie komunikatów
            5. Przetwarzanie komunikatów
         6. Usuwanie komunikatów z kolejki
         7. Obserwowanie kolejki komunikatów
            1. Robienie zrzutu bieżącej kolejki komunikatów
            2. Śledzenie przetwarzania kolejki komunikatów
      5. Komunikacja z wątkiem interfejsu użytkownika
      6. Podsumowanie
   4. 5. Komunikacja między procesami
      1. RPC systemu Android
         1. Binder
      2. Język AIDL
         1. Synchroniczne wywołanie RPC
         2. Asynchroniczne wywołanie RPC
      3. Przekazywanie komunikatów za pomocą obiektu Binder
         1. Komunikacja jednokierunkowa
         2. Komunikacja dwukierunkowa
      4. Podsumowanie
   5. 6. Zarządzanie pamięcią
      1. Odzyskiwanie pamięci
      2. Wycieki pamięci związane z wątkiem
         1. Wykonywanie wątku
            1. Klasy wewnętrzne
            2. Statyczne klasy wewnętrzne
            3. Niedopasowanie cyklu życia
         2. Komunikacja wątków
            1. Wysyłanie komunikatu danych
            2. Przesyłanie komunikatu zadań
      3. Unikanie wycieków pamięci
         1. Korzystanie ze statycznych klas wewnętrznych
         2. Korzystanie ze słabych referencji
         3. Zatrzymywanie wykonywania wątku roboczego
         4. Zachowanie wątków roboczych
         5. Czyszczenie kolejki komunikatów
      4. Podsumowanie
6. II. Techniki asynchroniczne
   1. 7. Zarządzanie cyklem życia wątku podstawowego
      1. Podstawy
         1. Cykl życia
         2. Przerwania
         3. Wyjątki nieprzechwycone
      2. Zarządzanie wątkami
         1. Definiowanie i uruchamianie
            1. Anonimowa klasa wewnętrzna
            2. Wątek publiczny
            3. Definiowanie wątku statycznej klasy wewnętrznej
            4. Podsumowanie opcji definiowania wątku
         2. Retencja
            1. Zachowywanie wątku w obiekcie Activity
            2. Zachowywanie wątku w klasie Fragment
      3. Podsumowanie
   2. 8. Klasa HandlerThread: wysokopoziomowy mechanizm kolejkowania
      1. Podstawy
      2. Cykl życia
      3. Przypadki użycia
         1. Powtarzające się wykonywanie zadania
         2. Zadania powiązane
            1. Przykład: persystencja danych z interfejsem SharedPreferences
         3. Łańcuchowanie zadań
            1. Przykład: łańcuchowane wywołania sieciowe
         4. Warunkowe wstawianie zadania
      4. Podsumowanie
   3. 9. Kontrola wykonywania wątku za pomocą frameworku wykonawcy
      1. Interfejs Executor
      2. Pule wątków
         1. Predefiniowane pule wątków
         2. Niestandardowe pule wątków
            1. Konfiguracja klasy ThreadPoolExecutor
         3. Projektowanie puli wątków
            1. Ustalanie rozmiaru
            2. Dynamika
            3. Ograniczona lub nieograniczona kolejka zadań
            4. Konfiguracja wątku
            5. Rozszerzanie klasy ThreadPoolExecutor
         4. Cykl życia
         5. Zamykanie puli wątków
         6. Przypadki użycia i pułapki pul wątków
            1. Faworyzowanie tworzenia wątku kosztem kolejkowania
            2. Obsługa wstępnie załadowanych kolejek zadań
            3. Niebezpieczeństwo zerowej liczby wątków podstawowych
      3. Zarządzanie zadaniami
         1. Reprezentacja zadania
         2. Zatwierdzanie zadań
            1. Zatwierdzenie pojedyncze
            2. Metoda invokeAll
            3. Metoda invokeAny
         3. Odrzucanie zadań
      4. Klasa ExecutorCompletionService
      5. Podsumowanie
   4. 10. Wiązanie zadania w tle z wątkiem interfejsu użytkownika za pomocą klasy AsyncTask
      1. Podstawy
         1. Tworzenie i uruchamianie
         2. Anulowanie
         3. Stany
            1. Przykład: ograniczenie wykonywania instancji AsyncTask do jednej naraz
      2. Implementacja klasy AsyncTask
         1. Przykład: pobieranie obrazów
      3. Wykonywanie zadania w tle
         1. Wykonywanie globalne dla aplikacji
         2. Wykonywanie zadań w różnych wersjach platformy
         3. Wykonywanie niestandardowe
            1. Przykład: nieglobalne wykonywanie sekwencyjne
      4. Alternatywy dla klasy AsyncTask
         1. Trywialne implementacje klasy AsyncTask
         2. Zadania w tle wymagające instancji Looper
         3. Usługa lokalna
         4. Korzystanie z metody execute(Runnable)
      5. Podsumowanie
   5. 11. Usługi
      1. Dlaczego warto wykorzystać komponent Service do wykonywania asynchronicznego?
      2. Usługi lokalne, zdalne i globalne
      3. Tworzenie i wykonywanie
      4. Cykl życia
      5. Usługa uruchamiana
         1. Implementacja metody onStartCommand
         2. Opcje ponownego uruchamiania
         3. Usługa kontrolowana przez użytkownika
            1. Przykład: połączenie Bluetooth
         4. Usługa kontrolowana przez zadanie
            1. Przykład: pobieranie współbieżne
      6. Usługa wiązana
         1. Wiązanie lokalne
      7. Wybór techniki asynchronicznej
      8. Podsumowanie
   6. 12. Klasa IntentService
      1. Podstawy
      2. Dobre sposoby wykorzystania klasy IntentService
         1. Zadania uporządkowane sekwencyjnie
            1. Przykład: komunikacja usług sieciowych
         2. Wykonywanie asynchroniczne w komponencie BroadcastReceiver
            1. Przykład: okresowe operacje długotrwałe
      3. Porównanie klas IntentService oraz Service
      4. Podsumowanie
   7. 13. Uzyskiwanie dostępu do klasy ContentProvider za pomocą klasy AsyncQueryHandler
      1. Krótkie wprowadzenie do klasy ContentProvider
      2. Uzasadnienie dla przetwarzania w tle klasy ContentProvider
      3. Korzystanie z klasy AsyncQueryHandler
         1. Przykład: rozszerzanie listy kontaktów
         2. Klasa AsyncQueryHandler
         3. Ograniczenia
      4. Podsumowanie
   8. 14. Automatyczne wykonywanie w tle za pomocą ładowarek
      1. Framework ładowarek
         1. Klasa LoaderManager
            1. Porównanie metod initLoader oraz restartLoader
         2. Interfejsy LoaderCallbacks
         3. Klasa AsyncTaskLoader
      2. Bezproblemowe ładowanie danych za pomocą ładowarki CursorLoader
         1. Korzystanie z ładowarki CursorLoader
         2. Przykład: lista kontaktów
         3. Dodawanie obsługi operacji CRUD
            1. Przykład: korzystanie z ładowarki CursorLoader za pomocą klasy AsyncQueryHandler
      3. Implementowanie niestandardowych ładowarek
         1. Cykl życia ładowarki
         2. Ładowanie w tle
            1. Przykład: prosta ładowarka niestandardowa
         3. Zarządzanie treścią
         4. Dostarczanie zbuforowanych rezultatów
         5. Przykład: niestandardowa ładowarka plików
         6. Obsługa wielu ładowarek
      4. Podsumowanie
   9. 15. Podsumowanie: wybór techniki asynchronicznej
      1. Zachowanie prostoty
      2. Zarządzanie zasobami i wątkami
      3. Wymiana komunikatów w celu uzyskania responsywności
      4. Unikanie nieoczekiwanego zakończenia zadania
      5. Łatwy dostęp do klasy ContentProvider
7. A. Bibliografia
   1. Książki
   2. Artykuły
   3. Prezentacje
8. B. O autorze
9. Indeks
10. Kolofon
11. Copyright