Применение условий в блокировках позволяет добиться контроля над управлением доступом к потокам. Условие блокировки представлет собой объект интерфейса Condition из пакета java.util.concurrent.locks.
Применение объектов Condition во многом аналогично использованию методов wait/notify/notifyAll класса Object, которые были рассмотрены в
одной из прошлых тем. В частности, мы можем использовать следующие методы интерфейса Condition:
await: поток ожидает, пока не будет выполнено некоторое условие и пока другой поток не вызовет методы signal/signalAll.
Во многом аналогичен методу wait класса Object
signalAll: сигнализирует всем потокам, у которых ранее был вызван метод await(), что они могут продолжить работу. Аналогичен методу notifyAll() класса Object
signal: сигнализирует, что поток, у которого ранее был вызван метод await(), может продолжить работу.
Применение аналогично использованию методу notify класса Object.
Поток для разблокировки выбирается из множества ожидающих случайным образом. С одной стороны, это эффективнее, чем разблокировать все потоки. Но если случайно выбранный поток обнаруживает, что он все еще не может продолжить выполнение, он снова блокируется. Если ни один другой поток снова не вызовет сигнал, программа блокируется.
Эти методы вызываются из блока кода, который попадает под действие блокировки ReentrantLock. Сначала, используя эту блокировку, нам надо получить объект Condition:
ReentrantLock locker = new ReentrantLock(); Condition condition = locker.newCondition();
Как правило, сначала проверяется условие доступа. Если соблюдается условие, то поток ожидает, пока условие не изменится:
while (условие)
condition.await();
После выполнения всех действий другим потокам подается сигнал об изменении условия:
condition.signalAll();
Важно в конце вызвать метод signal/signalAll, чтобы избежать возможности взаимоблокировки потоков.
Для примера возьмем задачу производителей и потребителей: производитель должен произвести 5 товаров, а покупатель должен эти товары купить. Однако на складе можно одновременно разместить не более 3 товаров. В то же время покупатель не может купить товар, если на складе нет никаких товаров. То есть покупатель должен ждать, пока производитель не произведет хотя бы один товар. А производитель должен ждать, пока покупатель не купит хотя бы один товар, если на складе 3 товара. И для решения этой задачи используем блокировки:
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
public class Program {
public static void main(String[] args) {
Store store=new Store();
Producer producer = new Producer(store);
Consumer consumer = new Consumer(store);
new Thread(producer).start();
new Thread(consumer).start();
}
}
// Класс Магазин, хранящий произведенные товары
class Store{
private int product=0;
ReentrantLock locker;
Condition condition;
Store(){
locker = new ReentrantLock(); // создаем блокировку
condition = locker.newCondition(); // получаем условие, связанное с блокировкой
}
public void get() {
locker.lock();
try{
// пока нет доступных товаров на складе, ожидаем
while (product<1)
condition.await();
product--;
System.out.println("Покупатель купил 1 товар");
System.out.println("Товаров на складе: " + product);
// сигнализируем
condition.signalAll();
}
catch (InterruptedException e){
System.out.println(e.getMessage());
}
finally{
locker.unlock();
}
}
public void put() {
locker.lock();
try{
// пока на складе 3 товара, ждем освобождения места
while (product>=3)
condition.await();
product++;
System.out.println("Производитель добавил 1 товар");
System.out.println("Товаров на складе: " + product);
// сигнализируем
condition.signalAll();
}
catch (InterruptedException e){
System.out.println(e.getMessage());
}
finally{
locker.unlock();
}
}
}
// класс Производитель
class Producer implements Runnable{
Store store;
Producer(Store store){
this.store=store;
}
public void run(){
for (int i = 1; i < 6; i++) {
store.put();
}
}
}
// Класс Потребитель
class Consumer implements Runnable{
Store store;
Consumer(Store store){
this.store=store;
}
public void run(){
for (int i = 1; i < 6; i++) {
store.get();
}
}
}
Разберем пошагово, что происходит. Итак, у нас есть следующие компоненты:
Store (Магазин): общий ресурс (буфер), к которому обращаются два потока. У него есть ограничение: он может хранить не более 3 товаров (product >= 3) и не менее 0 (product < 1).
Producer (Производитель): поток (Runnable), который пытается 5 раз добавить товар в Store (вызывая метод put()).
Consumer (Потребитель): поток (Runnable), который пытается 5 раз забрать товар из Store (вызывая метод get()).
Program: uлавный класс создает Store, Producer и Consumer, а затем запускает Producer и Consumer в двух отдельных потоках.
Ключевая логика находится в классе Store, который управляет доступом к переменной product.
ReentrantLock (locker): бокировка. Прежде чем производитель или потребитель смогут изменить количество товаров (product), они должны "захватить" эту блокировку. Это гарантирует, что только один поток (либо Producer, либо Consumer) может одновременно выполнять код внутри блоков try...finally в методах get() и put().
Condition (condition): условие, которое реализует "механизм ожидания", связанный с блокировкой. Оно позволяет потоку, который уже захватил блокировку, временно "уснуть" (освободив блокировку), пока не выполнится какое-то условие.
Метод put() в классе Producer (Производитель) выполняет следующие действия:
locker.lock(): Поток производителя захватывает блокировку.
while (product >= 3): Он проверяет, полон ли склад.
condition.await(): Если склад полон (3 товара), производитель засыпает и освобождает блокировку. Он будет ждать, пока его не "разбудит" потребитель.
product++: Если склад не полон (меньше 3), производитель добавляет 1 товар.
condition.signalAll(): Производитель "будит" все ожидающие потоки (в данном случае, он будит потребителя, если тот уснул из-за пустого склада).
locker.unlock(): Производитель отпускает блокировку.
Метод get() класса Consumer (Потребитель) выполняет следующие действия:
locker.lock(): Поток потребителя захватывает блокировку.
while (product < 1): Он проверяет, пуст ли склад.
condition.await(): Если склад пуст (0 товаров), потребитель засыпает и освобождает блокировку. Он будет ждать, пока его не "разбудит" производитель.
product--: Если на складе есть товары (1 или больше), потребитель забирает 1 товар.
condition.signalAll(): Потребитель "будит" все ожидающие потоки (производителя, если тот уснул из-за полного склада).
locker.unlock(): Потребитель отпускает блокировку.
Выполнение программы:
Два потока (Producer и Consumer) запускаются одновременно.
Они начинают "бороться" за блокировку locker.
Producer (скорее всего) захватит блокировку первым, добавит 3 товара (вызывая put() 3 раза) и на четвертой попытке уснет (т.к. product станет равен 3).
Consumer тем временем будет забирать товары. Как только он заберет хотя бы один товар, он вызовет signalAll(), что разбудит потребителя - объекта Producer.
Producer снова попытается добавить товар.
Процесс будет повторяться. Потоки будут поочередно производить и потреблять товары, при этом количество товаров на складе (product) никогда не будет больше 3.
В итоге Producer 5 раз добавит товар, а Consumer 5 раз его заберет, после чего оба потока завершат свою работу.
В итоге мы получим вывод наподобие следующего:
Производитель добавил 1 товар Товаров на складе: 1 Производитель добавил 1 товар Товаров на складе: 2 Производитель добавил 1 товар Товаров на складе: 3 Покупатель купил 1 товар Товаров на складе: 2 Покупатель купил 1 товар Товаров на складе: 1 Покупатель купил 1 товар Товаров на складе: 0 Производитель добавил 1 товар Товаров на складе: 1 Производитель добавил 1 товар Товаров на складе: 2 Покупатель купил 1 товар Товаров на складе: 1 Покупатель купил 1 товар Товаров на складе: 0
