Когда создается Looper?

Когда создается Looper

Looper — это объект, который управляет message queue для потока и обрабатывает сообщения в бесконечном цикле. Понимание момента его создания критично для правильной работы с Handler и многопоточностью в Android.

Основной момент создания

Looper создается автоматически для главного потока (UI thread). Когда Android стартует приложение, он инициализирует main thread с готовым Looper.

// В точке входа приложения (ActivityThread.main())
public static void main(String[] args) {
    Looper.prepareMainLooper();
    // ... инициализация остального
    Looper.loop();
}

Для рабочих потоков (background threads) Looper НЕ создается автоматически. Нужно создать его вручную.

Создание Looper вручную

// Способ 1: Через Looper.prepare() в потоке
thread {
    Looper.prepare() // Создает Looper для текущего потока
    
    val handler = Handler(Looper.myLooper()!!) {
        // Обработка сообщений
        true
    }
    
    Looper.loop() // Начинает обрабатывать сообщения
}

// Способ 2: HandlerThread (более удобно)
val handlerThread = HandlerThread("MyHandlerThread")
handlerThread.start()

val handler = Handler(handlerThread.looper) {
    // Обработка сообщений
    true
}

// Когда больше не нужен
handlerThread.quit() // или quitSafely()

Жизненный цикл Looper

// Этап 1: Подготовка (один раз на поток)
Looper.prepare()

// Этап 2: Получение текущего Looper
val looper = Looper.myLooper() // Для главного потока: Looper.getMainLooper()

// Этап 3: Создание Handler для работы с Looper
val handler = Handler(looper)

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

// Этап 5: Остановка (вызывается вне цикла loop())
Looper.myLooper()?.quit()

Практический пример с HandlerThread

class BackgroundService {
    private lateinit var handlerThread: HandlerThread
    private lateinit var handler: Handler
    
    fun initialize() {
        // Создание потока с Looper
        handlerThread = HandlerThread("BackgroundWorker")
        handlerThread.start() // Запускает поток и вызывает Looper.prepare()
        
        // Создание Handler для отправки сообщений
        handler = Handler(handlerThread.looper) { msg ->
            when (msg.what) {
                1 -> handleTask1()
                2 -> handleTask2()
            }
            true
        }
    }
    
    fun doWork() {
        // Отправка сообщения в message queue
        handler.sendMessage(Message.obtain(handler, 1))
    }
    
    fun cleanup() {
        // Остановка обработки сообщений и выход из loop()
        handlerThread.quitSafely()
    }
    
    private fun handleTask1() {
        Log.d("TAG", "Выполняю Task 1 в фоновом потоке")
    }
    
    private fun handleTask2() {
        Log.d("TAG", "Выполняю Task 2 в фоновом потоке")
    }
}

Отправка сообщений в Looper

// Способ 1: Через Handler
val handler = Handler(Looper.getMainLooper())
handler.post { 
    // Код выполнится в main thread
    tvText.text = "Updated"
}

// Способ 2: Отправка сообщения
val message = Message.obtain()
message.what = 1
message.obj = "Data"
handler.sendMessage(message)

// Способ 3: Отложенное выполнение
handler.postDelayed({ 
    // Выполнится через 2 секунды
}, 2000)

Разница между методами

Важные особенности

Один Looper на поток — каждый поток может иметь максимум один Looper

quit() vs quitSafely() — quit() немедленно останавливает, quitSafely() обрабатывает оставшиеся сообщения

Утечки памяти — забытые Handler в очереди могут привести к утечкам

Современная альтернатива — для новых проектов используй Kotlin Coroutines вместо Handler + Looper

Когда Looper нужен

• Обработка сообщений в фоновом потоке
• Долгоживущие сервисы
• Таймеры и повторяющиеся задачи
• Взаимодействие между потоками