База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Методи на ReentrantLock: придобиване, повторно влизане и условия

Разграничи блокиращия `lock()` от двата варианта на `tryLock()`, съпостави всяко успешно придобиване с `unlock()` и използвай отделни условия към една и съща ключалка.

Версия: Java SE 21

Синтаксис

// Java SE 21 — instance methods of java.util.concurrent.locks.ReentrantLock
public void lock()
public void unlock()
public boolean tryLock()
public boolean tryLock(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException
public java.util.concurrent.locks.Condition newCondition()
public int getHoldCount()

В Java SE 21 java.util.concurrent.locks.ReentrantLock е ключалка за взаимно изключване, която позволява повторно влизане. lock() изчаква, ако друга нишка държи ключалката; прекъсване на нишката не отменя чакането. Собственикът може да придобие същата ключалка отново, без да чака. getHoldCount() брои придобиванията на текущата нишка, които още не са уравновесени с отключване, а не чакащите нишки; 0 не означава, че ключалката е свободна.

unlock() намалява брояча с единица и освобождава ключалката едва при 0. Нишка, която не държи ключалката, получава IllegalMonitorStateException. Влез в блок try веднага след всяко успешно придобиване и сложи съответното unlock() във finally. Не отключвай заради неуспешен опит или опит, завършил с изключение. Ако кодът има нужда от двете ключалки, придобивай ги по всички пътища в един и същ ред, например gateLock преди orderLock, и ги освобождавай в обратен ред.

tryLock() не чака: връща false, ако друга нишка държи ключалката, и true при придобиване, включително при повторно влизане. Може да изпревари чакащите нишки дори при справедлива ключалка. tryLock(timeout, unit) спазва политиката за справедливост, ако е включена, чака най-много указаното време (timeout <= 0 означава без чакане) и връща false, ако не придобие ключалката в този срок. Прекъсване при влизане или по време на придобиването води до InterruptedException и изчиства флага за прекъсване; unit == null е недопустимо и води до NullPointerException.

Всяко извикване на newCondition() създава отделен обект Condition към същата ключалка. В буфер с едно място notEmpty е за потребителите, а notFull — за производителите. Извикване на signal() без да държиш ключалката води до IllegalMonitorStateException. await() първо проверява флага за прекъсване на текущата нишка. Ако флагът вече е вдигнат, await() го изчиства и хвърля InterruptedException, преди да провери дали нишката държи ключалката и без да я освобождава. В противен случай await() хвърля IllegalMonitorStateException, ако нишката не държи ключалката. Ако премине към чакане, await() атомарно освобождава ключалката и я придобива отново с първоначалната стойност на брояча, преди извикването да приключи. Проверявай състоянието в цикъл while, защото е възможно събуждане без сигнал. Подай сигнал след промяната на състоянието, докато още държиш ключалката; signal() не я освобождава.

Примери

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final class Slot {
        private final ReentrantLock lock = new ReentrantLock();
        private final Condition notEmpty = lock.newCondition();
        private final Condition notFull = lock.newCondition();
        private Integer value;

        void put(int item) throws InterruptedException {
            lock.lock();
            try {
                while (value != null) {
                    notFull.await();
                }
                value = item;
                notEmpty.signal();
            } finally {
                lock.unlock();
            }
        }

        int take() throws InterruptedException {
            lock.lock();
            try {
                while (value == null) {
                    notEmpty.await();
                }
                int item = value;
                value = null;
                notFull.signal();
                return item;
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock gateLock = new ReentrantLock();
        ReentrantLock orderLock = new ReentrantLock(true);

        System.out.println(orderLock.getHoldCount());
        orderLock.lock();
        try {
            orderLock.lock();
            try {
                System.out.println(orderLock.getHoldCount());
            } finally {
                orderLock.unlock();
            }
            System.out.println(orderLock.getHoldCount());
            if (orderLock.tryLock()) {
                try {
                    System.out.println(orderLock.getHoldCount());
                } finally {
                    orderLock.unlock();
                }
            }
            System.out.println(orderLock.getHoldCount());
        } finally {
            orderLock.unlock();
        }
        System.out.println(orderLock.getHoldCount());

        gateLock.lock();
        try {
            for (int attempt = 1; attempt <= 2; attempt++) {
                if (!orderLock.tryLock(10, TimeUnit.MILLISECONDS)) {
                    System.out.println("timed " + attempt + ": timeout");
                    continue;
                }
                try {
                    System.out.println("timed " + attempt + ": acquired");
                } finally {
                    orderLock.unlock();
                }
            }
        } finally {
            gateLock.unlock();
        }

        Slot slot = new Slot();
        slot.put(42);
        System.out.println("slot: " + slot.take());
    }
}

Резултат

0
2
1
2
1
0
timed 1: acquired
timed 2: acquired
slot: 42

Две извиквания на `lock()` дават първото `2` след началното `0`. Едно `unlock()` оставя `1`, а незабавното `tryLock()` от собственика връща брояча на `2`. Останалите две отключвания дават `1` и `0`. И двата опита с ограничено време използват една и съща `orderLock` и успяват без съревнование между нишки. `put(42)` и `take()` използват отделни условия към единствената ключалка на буфера; при това изпълнение нито една операция не чака.

Свързани уроци

  • Java · Урок 30 · Напреднало · Версия: 2
  • Java · Урок 54 · Средно · Версия: 2
  • Java · Урок 58 · Средно · Версия: 2

Източници