Java - Узел блокировки потока

Привет, будущие маги Java! Сегодня мы погрузимся в одну из самых сложных концепций в программировании на Java: Узел блокировки потока. Не волнуйтесь, если это звучит пугающе - к концу этого урока вы станете сыщиком узлов блокировки, способным обнаруживать и решать эти неприятные проблемы как профессионал!

Java - Thread Deadlock

Что такое узел блокировки потока?

Представьте себе, что вы на ужине, и вам нужны какой-то вилок и нож, чтобы поесть. Вы берете вилку, но когда вы достигаете для ножа, ваш друг уже взял его. В то же время ваш друг нуждается в вашей вилке, чтобы поесть, но вы не отпускаете её, пока не получите нож. Вы оба застряли, ждя, когда другой отпустит то, что вам нужно. Это, друзья, узел блокировки в реальной жизни!

В Java узел блокировки возникает, когда два или более потока заблокированы навсегда, каждый из которых ждет, когда другой освободит ресурс. Это как мексиканская дуэль, но с Java-потоками вместо ковбоев!

Понимание потоков и синхронизации

Перед тем как погружаться更深ль в узлы блокировки, давайте быстро пересмотрим некоторые ключевые концепции:

Потоки

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

Синхронизация

Синхронизация — это способ убедиться, что только один поток может получить доступ к общему ресурсу одновременно. Это как постановка знака "Не беспокоить" на двери номера в отеле.

Как возникают узлы блокировки

Узлы блокировки обычно возникают, когда выполняются четыре условия (известные как условия Кофмана):

Взаимное исключение: Не менее одного ресурса должно быть удерживаемо в неразделяемом режиме.
Держать и ждать: Поток должен удерживать по крайней мере один ресурс, пока ждет получения дополнительных ресурсов, удерживаемых другими потоками.
Нет принуждения: Ресурсы не могут быть насильно отняты у потока; они должны быть освобождены добровольно.
Круговая ожидать: Круговая цепочка из двух или более потоков, каждый из которых ждет ресурса, удерживаемого следующим потоком в цепочке.

Пример: Демонстрация ситуации узла блокировки

Давайте рассмотрим классический пример ситуации узла блокировки. Создадим два ресурса (представленных объектами) и два потока, которые пытаются получить эти ресурсы в разном порядке.

public class DeadlockExample {
private static Object resource1 = new Object();
private static Object resource2 = new Object();

public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 1: Holding Resource 1...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
System.out.println("Thread 1: Waiting for Resource 2...");
synchronized (resource2) {
System.out.println("Thread 1: Holding Resource 1 and Resource 2");
}
}
});

Thread thread2 = new Thread(() -> {
synchronized (resource2) {
System.out.println("Thread 2: Holding Resource 2...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
System.out.println("Thread 2: Waiting for Resource 1...");
synchronized (resource1) {
System.out.println("Thread 2: Holding Resource 2 and Resource 1");
}
}
});

thread1.start();
thread2.start();
}
}

Разберем это:

Мы создаем два экземпляра Object, resource1 и resource2, которые представляют наши общие ресурсы.
Мы создаем два потока:

thread1 пытается получить resource1 сначала, затем resource2.
thread2 пытается получить resource2 сначала, затем resource1.

Оба потока используют ключевое слово synchronized, чтобы заблокировать ресурсы.
Мы добавляем небольшую задержку (Thread.sleep(100)) для увеличения вероятности возникновения узла блокировки.

Когда вы выполните этот код, он, скорее всего, приведет к узлу блокировки. Поток 1 получит resource1 и будет ждать resource2, а поток 2 получит resource2 и будет ждать resource1. Ни один из потоков не сможет продолжить, что приведет к узлу блокировки.

Пример решения узла блокировки

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

public class DeadlockSolutionExample {
private static Object resource1 = new Object();
private static Object resource2 = new Object();

public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 1: Holding Resource 1...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
synchronized (resource2) {
System.out.println("Thread 1: Holding Resource 1 and Resource 2");
}
}
});

Thread thread2 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 2: Holding Resource 1...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
synchronized (resource2) {
System.out.println("Thread 2: Holding Resource 1 and Resource 2");
}
}
});

thread1.start();
thread2.start();
}
}

В этом решении:

Оба потока теперь получают resource1 сначала, затем resource2.
Это обеспечивает последовательный порядок получения ресурсов, предотвращая круговую ожиду.

Лучшие практики для избежания узлов блокировки

Всегда получайте блокировки в одном и том же порядке: Как мы видели в нашем примере решения, это предотвращает круговую ожиду.
Избегайте вложенных блокировок: Старайтесь минимизировать количество синхронизированных блоков.
Используйте tryLock() с таймаутом: Вместо бесконечного ожидания используйте tryLock() с таймаутом, чтобы попытаться получить блокировку в течение определенного периода времени.
Избегайте длительного удержания блокировок: Освобождайте блокировки, как только вы закончили работу с общим ресурсом.

Заключение

Поздравляем! Вы только что разгадали тайны узлов блокировки Java. Помните, что написание многопоточных программ — это как постановка сложного танца — это требует-careful планирования и координации, чтобы все танцоры (потоки) двигались гладко, не наступая друг другу на ноги (или блокируя друг друга ресурсы).

Как вы продолжаете свое путешествие по Java, держите эти концепции в голове, и вы будете хорошо подготовлены к написанию эффективных, безузловых многопоточных программ. Счастливого кодирования, и пусть ваши потоки всегда будут в гармонии!

Метод	Описание
`synchronized`	Ключевое слово, используемое для создания синхронизированных блоков или методов
`Object.wait()`	Приостанавливает текущий поток до тех пор, пока другой поток не вызовет `notify()` или `notifyAll()`
`Object.notify()`	Пробуждает один поток, ожидающий на этом объекте
`Object.notifyAll()`	Пробуждает все потоки, ожидающие на этом объекте
`Thread.sleep(long millis)`	Заставляет текущий выполняемый поток заснуть на указанное количество миллисекунд
`Lock.tryLock()`	Получает блокировку только, если она свободна в момент вызова
`Lock.tryLock(long time, TimeUnit unit)`	Получает блокировку, если она свободна в течение заданного времени ожидания
`ReentrantLock.lock()`	Получает блокировку
`ReentrantLock.unlock()`	Освобождает блокировку

Помните, что эти методы — это мощные инструменты в вашем наборе для многопоточности. Используйте их мудро, и вы создадите надежные, эффективные Java-приложения в кратчайшие сроки!

Credits: Image by storyset

Предыдущий учебник:

Java - межниточный обмен

Следующий учебник:

Java - прерывание потока