Что такое состояние потоков?

# Состояния потоков в Java

Поток в Java проходит через несколько состояний (states) во время своего жизненного цикла. Состояние потока определяется enum Thread.State и отражает текущую активность потока в операционной системе и виртуальной машине Java.

Шесть основных состояний

1. NEW (Новый)

Поток создан, но ещё не запущен. Это состояние существует от момента создания объекта Thread до вызова метода start():

Thread thread = new Thread(() -> System.out.println("Hello"));
System.out.println(thread.getState()); // NEW
thread.start();

2. RUNNABLE (Готов к запуску)

Поток готов выполняться и находится в очереди планировщика потоков. Это не значит, что он в данный момент выполняется, а лишь что он может быть выбран для выполнения:

Thread thread = new Thread(() -> {
    System.out.println(thread.getState()); // Может быть RUNNABLE
});
thread.start();

3. BLOCKED (Заблокирован)

Поток попытался получить блокировку (monitor lock), которую держит другой поток. Он ждёт, пока освободится эта блокировка:

public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
}

Counter counter = new Counter();
Thread t1 = new Thread(() -> {
    while(true) counter.increment();
});
Thread t2 = new Thread(() -> {
    System.out.println(t1.getState()); // Может быть BLOCKED
    counter.increment();
});

4. WAITING (Ожидает)

Поток ждёт неопределённо долго, пока другой поток выполнит определённое действие (например, вызовет notify() или завершится). Методы, вызывающие это состояние:

• Object.wait()
• Thread.join()
• LockSupport.park()

Object monitor = new Object();

Thread thread = new Thread(() -> {
    synchronized(monitor) {
        try {
            monitor.wait();  // Переходит в WAITING
        } catch(InterruptedException e) {
            // ...
        }
    }
});
thread.start();

Thread.sleep(100);
System.out.println(thread.getState()); // WAITING

synchronized(monitor) {
    monitor.notify();  // Пробуждает поток
}

5. TIMED_WAITING (Ожидает с таймаутом)

Поток ждёт определённое время. Отличается от WAITING наличием таймаута:

• Thread.sleep(millis)
• Object.wait(millis)
• Thread.join(millis)
• LockSupport.parkNanos()

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(5000);  // Переходит в TIMED_WAITING на 5 сек
    } catch(InterruptedException e) {
        // ...
    }
});
thread.start();

Thread.sleep(100);
System.out.println(thread.getState()); // TIMED_WAITING

6. TERMINATED (Завершён)

Поток завершил выполнение и больше не будет запущен:

Thread thread = new Thread(() -> System.out.println("Done"));
thread.start();
thread.join();  // Ждём завершения
System.out.println(thread.getState()); // TERMINATED

Диаграмма переходов

NEW → (start) → RUNNABLE ↔ BLOCKED → WAITING → TIMED_WAITING → TERMINATED

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

public class ThreadStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("Поток начал работу");
            try {
                Thread.sleep(2000);  // TIMED_WAITING
            } catch(InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        System.out.println("До start: " + thread.getState());     // NEW
        thread.start();
        
        Thread.sleep(100);
        System.out.println("После start: " + thread.getState());  // RUNNABLE
        
        Thread.sleep(100);
        System.out.println("При sleep: " + thread.getState());    // TIMED_WAITING
        
        thread.join();
        System.out.println("После join: " + thread.getState());   // TERMINATED
    }
}

Различие между BLOCKED и WAITING

• BLOCKED: поток пытается получить синхронизацию (monitor lock)
• WAITING: поток добровольно освободил ресурсы и ждёт сигнала

Выводы

Понимание состояний потоков критично для:

• Отладки многопоточных приложений
• Диагностики deadlock'ов
• Оптимизации производительности
• Правильного использования синхронизации