Что находится внутри ActivityThread, позволяющее жить приложению вечно

Краткий ответ

Внутри ActivityThread находится не один механизм, а целая система компонентов Android Framework, главным из которых является цикл сообщений (Main Looper и Handler), управляемый Looper'ом в главном потоке (UI Thread). Именно бесконечный цикл Looper.loop() не дает главному потоку завершиться, позволяя приложению "жить вечно" в активном состоянии. Однако ключевое уточнение: само приложение не живет "вечно" — его жизненный цикл контролируется системой, которая может завершить процесс в любой момент при нехватке ресурсов.

Подробное объяснение внутренней структуры и механизмов

1. Ядро: Main Looper и цикл сообщений (Message Queue)

ActivityThread — это не публичный класс, а точка входа для запуска приложения. При создании процесса система вызывает его статический метод main(). Вот что происходит внутри:

public static void main(String[] args) {
    // Инициализация основного Looper'а
    Looper.prepareMainLooper();

    // Создание экземпляра ActivityThread
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);

    // Получение Handler'а для главного потока
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }

    // Запуск бесконечного цикла обработки сообщений
    Looper.loop();

    // Строка ниже никогда не выполнится в нормальных условиях
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

Looper.loop() — это бесконечный цикл while (true), который постоянно извлекает сообщения (Message) из очереди (MessageQueue) и передает их на обработку соответствующему Handler'у. Пока в очереди есть сообщения или поток не заблокирован в ожидании новых, цикл продолжает работу.

2. Ключевые компоненты внутри ActivityThread

А. H (класс Handler)

Внутри ActivityThread определен внутренний класс H, расширяющий Handler. Он обрабатывает системные сообщения, связанные с жизненным циклом компонентов:

private class H extends Handler {
    public static final int LAUNCH_ACTIVITY = 100;
    public static final int PAUSE_ACTIVITY = 101;
    public static final int STOP_ACTIVITY = 102;
    // ... десятки других констант

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case LAUNCH_ACTIVITY:
                handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                break;
            case PAUSE_ACTIVITY:
                handlePauseActivity((IBinder) msg.obj, false, ...);
                break;
            // ... обработка всех жизненных циклов
        }
    }
}

Б. ApplicationThread (Binder-прокси)

Это private final класс, реализующий интерфейс IApplicationThread. Он выступает Binder-прокси для межпроцессного взаимодействия (IPC) с системным процессом ActivityManagerService:

• Принимает вызовы от AMS (запуск активностей, пауза, конфигурационные изменения)
• Преобразует Binder-вызовы в сообщения Message
• Отправляет эти сообщения в очередь главного потока через H

В. ResourcesManager и другие менеджеры

ActivityThread содержит ссылки на:

• ResourcesManager — управление ресурсами приложения
• ArrayMap<Activity, ActivityClientRecord> — запись о запущенных активностях
• Application — экземпляр класса приложения

3. Почему приложение не завершается сразу?

А. Архитектура на основе событий (event-driven)

Android приложение реагирует на события:

1. Пользовательский ввод (касания, клавиши)
2. Системные события (входящий звонок, изменение ориентации)
3. Свои сообщения (Handler.postDelayed, обновление UI)

Каждое событие становится Message в MessageQueue.

Б. Блокирующее чтение из очереди

Когда очередь сообщений пуста, поток не завершается, а блокируется в MessageQueue.next():

// Упрощенная логика Looper.loop()
public static void loop() {
    final MessageQueue queue = me.mQueue;
    for (;;) {
        Message msg = queue.next(); // Блокируется здесь при пустой очереди
        if (msg == null) return; // Выход только при остановке Looper'а
        msg.target.dispatchMessage(msg); // Обработка сообщения
    }
}

В. Системный контроль жизненного цикла

Важно понимать: система Android может убить процесс приложения в любой момент при нехватке памяти, даже если Looper.loop() работает. ActivityThread лишь обеспечивает корректную обработку событий, пока системе нужно, чтобы приложение было alive.

4. Что происходит при "завершении" приложения?

1. Пользователь закрывает все активности → система отправляет сообщение DESTROY_ACTIVITY
2. ActivityThread получает его через ApplicationThread → H → handleDestroyActivity()
3. Но процесс может оставаться живым в фоне для быстрого перезапуска (кешированный процесс)
4. Система решила освободить память → убивает процесс без вызова onDestroy() у ActivityThread

Вывод

"Вечность" жизни Android-приложения — это иллюзия, создаваемая:

1. Бесконечным циклом Looper.loop() в главном потоке
2. Архитектурой на основе сообщений через Handler/Looper
3. Межпроцессным взаимодействием через Binder и ApplicationThread

Однако реальный контроль над жизнью процесса принадлежит ActivityManagerService, который может завершить приложение в любой момент, основываясь на приоритете процесса и доступности системных ресурсов. ActivityThread лишь обеспечивает корректный механизм обработки событий, пока система разрешает приложению существовать.