Зачем в Thread надо передавать интерфейс Runnable, внутри которой есть функция run

Зачем Thread принимает Runnable

В Java (и, соответственно, в Android, хотя в Android разработке Thread напрямую используется реже в пользу более высокоуровневых механизмов) класс Thread принимает в конструкторе объект, реализующий интерфейс Runnable. Это классический пример паттерна проектирования Стратегия (Strategy), который обеспечивает разделение механизма выполнения задачи (Thread как средство параллельного выполнения) от содержания самой задачи (логика в методе run()).

Основные причины такого подхода

1. Разделение ответственности (Separation of Concerns)

Класс Thread отвечает за:

• Управление жизненным циклом потока (создание, запуск, прерывание, ожидание завершения).
• Взаимодействие с планировщиком потоков ОС.
• Управление приоритетами и демоническим статусом.

Интерфейс Runnable (с единственным методом run()) определяет:

• Контракт на выполнение: что именно должно быть выполнено в новом потоке.
• Это чистый интерфейс задачи, не связанный со сложной логикой управления потоком.

Благодаря этому разделению, логика задачи становится переиспользуемой и тестируемой отдельно от многопоточного кода.

// Задача (Runnable) может быть выполнена независимо от Thread
Runnable myTask = new Runnable() {
    @Override
    public void run() {
        // Чистая бизнес-логика
    }
};

// Её можно выполнить в отдельном потоке
Thread thread = new Thread(myTask);
thread.start();

// Или, например, в пуле потоков (ExecutorService)
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(myTask);

2. Гибкость и расширяемость

• Поскольку Runnable — это интерфейс, вы можете передать любой объект, который его реализует. Это может быть:

     - Анонимный класс.
     - Лямбда-выражение (в Java 8+).
     - Отдельный класс, реализующий `Runnable`.
     - Даже сам `Thread` (поскольку `Thread` также реализует `Runnable`, но это считается плохой практикой для разделения ответственности).

• Это позволяет динамически менять выполняемый код, не меняя логику управления потоком.
• Задачу можно выполнить не только в новом потоке, но и в существующем (просто вызвав run()), или передать в различные исполнители (Executor, Handler в Android).

3. Избегание ограничений одиночного наследования в Java

Класс Thread уже расширяет класс Object. Если бы задача задавалась путём наследования от Thread и переопределения метода run(), то ваш класс не смог бы наследовать какой-либо другой полезный класс (например, Activity или Fragment в Android — хотя в их случае наследование от Thread было бы архитектурной ошибкой). Реализация интерфейса Runnable позволяет вашему классу сохранить возможность наследования от другого базового класса, соблюдая принцип «предпочитайте композицию наследованию».

// Плохо: теряем возможность наследовать другой класс
class MyThread extends Thread {
    @Override
    public void run() {
        // Логика
    }
}

// Хорошо: можем наследовать нужный класс и реализовать Runnable
class MyActivity extends Activity implements Runnable {
    @Override
    public void run() {
        // Логика для фонового выполнения
    }
}

4. Совместимость с пулами потоков и современными API

Современные многопоточные API в Java (пакет java.util.concurrent) и Android (например, ExecutorService, AsyncTask — deprecated, Kotlin Coroutines) построены вокруг концепции задач (Runnable или Callable). Thread, принимающий Runnable, идеально вписывается в эту экосистему. Задачу, переданную в Thread, можно так же легко передать в ExecutorService, что обеспечивает единый контракт для асинхронного выполнения.

Пример на Android с Runnable и Handler

Хотя прямой Thread в Android используется редко, принцип Runnable повсеместен. Например, для выполнения кода в UI-потоке:

// Kotlin пример (принцип тот же)
val handler = Handler(Looper.getMainLooper())

// Runnable определяет задачу для UI-потока
val updateUiTask = Runnable {
    textView.text = "Обновлено из фонового потока"
}

// Выполняем эту задачу в фоновом потоке
Thread {
    // Долгая операция
    Thread.sleep(1000)
    // Затем передаём задачу обновления UI в главный поток
    handler.post(updateUiTask)
}.start()

Заключение

Передача Runnable в Thread — это не техническая необходимость, а продуманное архитектурное решение. Оно обеспечивает гибкость, переиспользуемость кода, соблюдение принципов SOLID (в частности, принципа открытости/закрытости и разделения интерфейсов) и совместимость с современными системами управления многопоточностью. Это позволяет писать более чистый, поддерживаемый и тестируемый асинхронный код, что критически важно в разработке под Android, где неправильная работа с потоками приводит к «зависаниям» UI и плохому пользовательскому опыту.