В чем разница между sleep и yield?

# Разница между sleep() и yield()

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

Thread.sleep() - останавливает текущий поток на определенное время. Поток переходит в TIMED_WAITING состояние.

Thread.yield() - намекает scheduler-у, что текущий поток готов уступить процессорное время другим потокам. Поток остается в RUNNABLE состоянии.

Подробное сравнение

1. Thread.sleep()

Что делает: Останавливает текущий поток на указанное время

Синтаксис:

try {
    Thread.sleep(1000);  // 1000 миллисекунд = 1 секунда
} catch (InterruptedException e) {
    e.printStackTrace();
}

Состояние потока: TIMED_WAITING

Характеристики:

• Гарантирует, что поток не будет выполняться минимум N миллисекунд
• Проверяет InterruptedException
• Может быть прервана через interrupt()
• Thread-safe

Пример:

public class SleepExample implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Iteration " + i + " at " + System.currentTimeMillis());
            try {
                Thread.sleep(1000);  // Ждет 1 секунду
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted");
            }
        }
    }
}

public static void main(String[] args) {
    Thread thread = new Thread(new SleepExample());
    thread.start();
    // Вывод:
    // Iteration 1 at 1000
    // Iteration 2 at 2000
    // Iteration 3 at 3000
    // ...
}

Когда использовать:

• Нужна точная задержка
• Нужно освободить процессор на время
• Таймеры и расписания
• Задержки между попытками (retry logic)
• Имитация долгих операций в тестах

2. Thread.yield()

Что делает: Намекает scheduler-у, что текущий поток готов уступить процессорное время

Синтаксис:

Thread.yield();  // Нет параметров, нет исключений

Состояние потока: RUNNABLE (не меняется)

Характеристики:

• Это просто намек, scheduler может его проигнорировать
• Не гарантирует, что поток будет переключен
• Поток может сразу же получить процессор
• Не проверяет исключения
• Зависит от реализации JVM

Пример:

public class YieldExample implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            Thread.yield();  // Намек на переключение
        }
    }
}

public static void main(String[] args) {
    Thread thread1 = new Thread(new YieldExample(), "Thread-1");
    Thread thread2 = new Thread(new YieldExample(), "Thread-2");
    thread1.start();
    thread2.start();
    // Вывод может быть разным, зависит от scheduler
}

3. Детальное сравнение

4. Критическое различие - освобождение LOCK

Это очень важное различие!

sleep() - освобождает монитор

public synchronized void testSleep() {
    try {
        System.out.println("Holding lock, sleeping...");
        Thread.sleep(2000);  // Освобождает монитор!
        System.out.println("Woke up, still holding lock");
    } catch (InterruptedException e) {}
}

// Другой поток может войти в этот метод во время sleep!
public synchronized void otherMethod() {
    System.out.println("I can run while sleep() is executing!");
}

yield() - НЕ освобождает монитор

public synchronized void testYield() {
    System.out.println("Holding lock, yielding...");
    Thread.yield();  // НЕ освобождает монитор!
    System.out.println("Still holding lock");
}

// Другой поток НЕ может войти в synchronized методы класса!
public synchronized void otherMethod() {
    System.out.println("I CANNOT run while yield() is executing!");
}

5. Примеры использования

sleep() - типичные случаи

// 1. Polling с задержкой
while (!done) {
    try {
        Thread.sleep(100);  // Проверяем каждые 100мс
        checkStatus();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        break;
    }
}

// 2. Retry logic
int attempts = 0;
while (attempts < 5) {
    try {
        connectToServer();
        break;
    } catch (ConnectionException e) {
        attempts++;
        if (attempts < 5) {
            Thread.sleep(1000 * attempts);  // Экспоненциальная задержка
        }
    }
}

// 3. Таймер
while (true) {
    try {
        System.out.println("Tick");
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        break;
    }
}

yield() - редкое использование

// Очень редко используется, в основном для тестирования
public class ProducerConsumer {
    public void produce() {
        for (int i = 0; i < 100; i++) {
            queue.put(i);
            Thread.yield();  // Дать шанс consumer
        }
    }
    
    public void consume() {
        for (int i = 0; i < 100; i++) {
            Object item = queue.get();
            Thread.yield();  // Дать шанс producer
        }
    }
}

6. Тестирование race conditions

// yield() может помочь выявить race conditions
public class RaceConditionTest {
    private int counter = 0;
    
    public void increment() {
        for (int i = 0; i < 1000; i++) {
            counter++;  // NOT thread-safe
            Thread.yield();  // Увеличивает шанс race condition
        }
    }
    
    // Без yield() можно не заметить баг!
    // С yield() баг проявится чаще
}

7. Таблица состояний потока

До операции:        RUNNABLE (выполняется)
         ↓
leep(1000) ------→ TIMED_WAITING (1 сек) ------→ RUNNABLE
         ↓
ield() ----------→ RUNNABLE (может выполняться сразу)

8. Важные заметки

sleep()

// ВСЕГДА оборачивай в try-catch
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();  // Восстанови interrupt флаг
    // или обработай ошибку
}

// Никогда так не делай (проглотишь исключение)
Thread.sleep(1000);  // ОШИБКА - не скомпилируется

yield()

// Не полагайся на yield() для синхронизации
// Используй правильные механизмы синхронизации:
// - synchronized блоки
// - Lock интерфейс
// - CountDownLatch, Barrier и т.д.

// Плохо (ненадежно)
while (!done) {
    Thread.yield();
}

// Хорошо (надежно)
wait done на CountDownLatch или AtomicBoolean

9. Производительность

// sleep() - явно замораживает поток
public void slowLoop() {
    for (int i = 0; i < 1000000; i++) {
        doWork();
        Thread.sleep(1);  // ОЧЕНЬ медленно!
    }
}

// yield() - просто намек, может быть быстрее
public void fasterLoop() {
    for (int i = 0; i < 1000000; i++) {
        doWork();
        Thread.yield();  // Может быть быстрее (или одинаково)
    }
}

Заключение

• sleep() - гарантированная задержка, останавливает поток на время, освобождает монитор
• yield() - ненадежный намек, не гарантирует переключение, НЕ освобождает монитор
• sleep() часто используется, yield() редко
• Для синхронизации используй правильные механизмы (synchronized, Lock, и т.д.)
• yield() полезна для выявления race conditions при тестировании