Что хотят услышать интервьюеры:

Livelock — это ситуация, когда потоки не заблокированы, но постоянно реагируют друг на друга и не продвигаются к завершению. В отличие от deadlock, здесь работа вроде бы продолжается, но полезного прогресса нет. Обычно это происходит из-за слишком «вежливого» алгоритма, когда потоки бесконечно уступают друг другу.

Определение:

Livelock в многопоточности — это состояние, при котором один или несколько потоков активно выполняются, но из-за постоянного изменения состояния, повторных попыток или уступок не могут завершить задачу.

Ключевое отличие от deadlock: при deadlock потоки ждут навсегда, а при livelock они не ждут, а продолжают работать, но без результата.

Пример использования:

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

import java.util.concurrent.locks.ReentrantLock;

public class LivelockExample {
    private static final ReentrantLock lockA = new ReentrantLock();
    private static final ReentrantLock lockB = new ReentrantLock();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> doWork(lockA, lockB), "T1");
        Thread t2 = new Thread(() -> doWork(lockB, lockA), "T2");

        t1.start();
        t2.start();
    }

    private static void doWork(ReentrantLock first, ReentrantLock second) {
        while (true) {
            if (first.tryLock()) {
                try {
                    if (second.tryLock()) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " completed work");
                            return;
                        } finally {
                            second.unlock();
                        }
                    }
                } finally {
                    first.unlock();
                }
            }

            // Поток "уступает" и пытается снова
            Thread.yield();
        }
    }
}

Пояснение кода:

Код показывает классический сценарий livelock на двух ReentrantLock.

Каждый поток пытается захватить первый замок через tryLock(), чтобы не блокироваться.
Если второй замок недоступен, поток освобождает первый замок.
Оба потока могут делать это одновременно и снова мешать друг другу.
В результате они постоянно выполняются, но ни один не доходит до секции, где работа завершается.
Thread.yield() здесь усиливает эффект «вежливого» ожидания, но не гарантирует устранение проблемы.

Ключевые моменты:

Livelock — это «активное ожидание без прогресса».
В livelock потоки не заблокированы, но бесконечно повторяют действия.
Главная причина — слишком частые уступки, повторные попытки или симметричное поведение потоков.
Важно отличать livelock от deadlock: в deadlock потоки стоят, в livelock — крутятся.
Для снижения риска используют таймауты, случайные задержки, строгий порядок захвата ресурсов или изменение алгоритма координации.

Можете объяснить концепцию Livelock в контексте многопоточности на Java?