Java Multithreading: Концепции, жизненный цикл и практические примеры кода

Java-приложения часто должны выполнять несколько задач одновременно. Это руководство проведет вас через однопоточное и многопоточное выполнение, жизненный цикл потока, техники синхронизации и практические примеры кода, иллюстрирующие каждую концепцию.

Что такое одиночный поток (Single Thread)?

Одиночный поток в Java — это наименьшая единица выполнения. Java runtime создает пользовательский поток при запуске приложения, и вы можете добавлять дополнительные пользовательские или демон-потоки по мере необходимости. Демон-потоки работают в фоне и не препятствуют выходу JVM.

Пример одиночного потока:

package demotest;
public class GuruThread {
    public static void main(String[] args) {
        System.out.println("Single Thread");
    }
}

Преимущества однопоточного выполнения:

• Минимальные накладные расходы — поддерживается только один контекст выполнения.
• Упрощенная отладка и сопровождение.

Что такое многопоточность (Multithreading) в Java?

Многопоточность позволяет двум или более потокам работать одновременно, максимизируя использование CPU. Потоки разделяют одно и то же пространство памяти, поэтому переключения контекста быстрые, а использование памяти остается низким.

Пример создания двух параллельных потоков:

package demotest;
public class GuruThread1 implements Runnable {
    public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
        // Логика потока идет сюда
    }
}

Преимущества многопоточности:

• Неблокирующий UI и фоновая обработка.
• Устойчивость — исключение в одном потоке не останавливает другие.

Жизненный цикл потока в Java

Жизненный цикл потока состоит из пяти отдельных состояний:

1. New — Поток инстанцирован, но не запущен.
2. Runnable — Поток запущен и готов к выполнению.
3. Running — Поток активно выполняется.
4. Waiting — Поток приостановлен до возникновения определенного события.
5. Dead — Поток завершил выполнение.

Ключевые методы потока

Метод	Описание
start()	Начинает выполнение потока; JVM вызывает run().
sleep(long milliseconds)	Приостанавливает текущий поток на указанную продолжительность.
getName()	Возвращает имя потока.
setPriority(int newPriority)	Настраивает приоритет потока (1-10).
yield()	Предлагает планировщику приостановить текущий поток.

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

Ниже приведен краткий пример, демонстрирующий создание потока, настройку приоритета и сон.

package demotest;
public class ThreadExample1 implements Runnable {
    @Override
    public void run() {
        // Работа потока здесь
    }
    public static void main(String[] args) {
        Thread guruThread1 = new Thread();
        guruThread1.start();
        try {
            Thread.sleep(1000); // пауза на 1 секунду
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        guruThread1.setPriority(1);
        System.out.println(guruThread1.getPriority());
        System.out.println("Thread Running");
    }
}

Пример вывода:

Синхронизация потоков

Когда несколько потоков обращаются к общим ресурсам, синхронизация обеспечивает согласованность данных. В Java вы можете обернуть критические секции ключевым словом synchronized, гарантируя эксклюзивный доступ.

synchronized(object) {
    // синхронизированный блок
}

Расширенный пример многопоточности

Ниже приведен более сложный пример, создающий два потока, каждый из которых печатает свое имя и счетчик с задержкой в одну секунду.

package demotest;
public class GuruThread2 {
    public static void main(String[] args) {
        GuruThread3 threadGuru1 = new GuruThread3("guru1");
        threadGuru1.start();
        GuruThread3 threadGuru2 = new GuruThread3("guru2");
        threadGuru2.start();
    }
}
class GuruThread3 implements Runnable {
    private Thread guruthread;
    private String guruname;
    GuruThread3(String name) {
        this.guruname = name;
    }
    @Override
    public void run() {
        System.out.println("Thread running " + guruname);
        for (int i = 0; i < 4; i++) {
            System.out.println(i);
            System.out.println(guruname);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread has been interrupted");
            }
        }
    }
    public void start() {
        System.out.println("Thread started");
        if (guruthread == null) {
            guruthread = new Thread(this, guruname);
            guruthread.start();
        }
    }
}

Типичный вывод (иллюстрирован на сопровождающем изображении):

Основные выводы

• Многопоточность освобождает приложение от блокирующих вызовов и позволяет параллельные операции.
• Жизненный цикл потока — New, Runnable, Running, Waiting, Dead — определяет состояния, через которые проходит поток.
• Синхронизация необходима, когда потоки разделяют данные, предотвращая race conditions.
• Практические примеры кода укрепляют понимание создания потоков, управления жизненным циклом и синхронизации.