Reetrant блокировки в java

Я немного изменил ваш код и попробовал его для себя.

Я обнаружил, что ReentrantLock.tryLock выдает исключение IllegalMonitorStateException независимо от того, что я делаю. Я не думаю, что это уместно.

package concurrency;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * LockableTask is a nice demonstration
 * @author Michael
 * @link https://stackoverflow.com/questions/32680954/reetrant-locks-in-java
 * @since 9/20/2015 11:25 AM
 */
public class LockableTask implements Runnable {

    private static final int DEFAULT_WAIT = 100;
    private static final int DEFAULT_TIMEOUT = 1000;
    private static final int DEFAULT_THREADS = 5;

    private ReentrantLock lock;
    private int waitPeriod;
    private int timeoutPeriod;
    private boolean halfHeartedLockRequest;

    public static void main(String[] args) {
        long begTime = System.currentTimeMillis();
        System.out.println("Start reentrant lock test");
        try {
            LockableTask lockableTask = new LockableTask(true, false);
            int numThreads = (args.length > 0) ? Integer.parseInt(args[0]) : DEFAULT_THREADS;
            List<Thread> threads = new ArrayList<>(numThreads);
            for (int i = 0; i < numThreads; ++i) {
                threads.add(new Thread(lockableTask));
            }
            for (Thread thread : threads) {
                thread.start();
            }
        } finally {
            long endTime = System.currentTimeMillis();
            System.out.println(String.format("Complete reentrant lock test in %d milliseconds", (endTime-begTime)));
        }
    }

    public LockableTask() {
        this(false, false, DEFAULT_WAIT, DEFAULT_TIMEOUT);
    }

    public LockableTask(boolean halfHeartedLockRequest, boolean fair) {
        this(halfHeartedLockRequest, fair, DEFAULT_WAIT, DEFAULT_TIMEOUT);
    }

    public LockableTask(boolean halfHeartedLockRequest, boolean fair, int waitPeriod, int timeoutPeriod) {
        this.halfHeartedLockRequest = halfHeartedLockRequest;
        this.lock = new ReentrantLock(fair);
        this.waitPeriod = (waitPeriod > 0) ? waitPeriod : DEFAULT_WAIT;
        this.timeoutPeriod = (timeoutPeriod > 0) ? timeoutPeriod : DEFAULT_TIMEOUT;
    }

    @Override
    public void run() {
        System.out.println(String.format("Thread '%s' requests lock ", Thread.currentThread().getName()));
        if (this.halfHeartedLockRequest) {
            this.lock.tryLock();
        } else {
            this.lock.lock();
        }
        try {
            System.out.println(String.format("Thread '%s' acquires lock for %d ", Thread.currentThread().getName(), this.waitPeriod));
            TimeUnit.MILLISECONDS.sleep(this.waitPeriod);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            this.lock.unlock();
            System.out.println(String.format("Thread '%s' releases lock ", Thread.currentThread().getName()));
        }
    }
}

Причина в том, что tryLock никогда не блокируется, если блокировка уже удерживается другим потоком.

Ниже приведена документация о tryLock().

публичное логическое значение tryLock()

Получает блокировку только в том случае, если она не удерживается другим потоком во время вызова.

Получает блокировку, если она не удерживается другим потоком, и немедленно возвращается со значением true, устанавливая счетчик удержания блокировки равным единице. Даже если эта блокировка настроена на использование политики честного порядка, вызов tryLock() немедленно получит блокировку, если она доступна, независимо от того, ожидают ли другие потоки блокировки в данный момент. Такое «навязчивое» поведение может быть полезным в определенных обстоятельствах, даже если оно нарушает справедливость. Если вы хотите соблюдать настройку справедливости для этой блокировки, используйте tryLock(0, TimeUnit.SECONDS), который почти эквивалентен (он также обнаруживает прерывание).

Если текущий поток уже удерживает эту блокировку, то счетчик удержания увеличивается на единицу, и метод возвращает значение true.

Если блокировка удерживается другим потоком, этот метод немедленно возвращает значение false.

ReentrantLock#tryLock() — получает блокировку только в том случае, если она не удерживается другим потоком во время вызова, и возвращает true, если успешно, иначе false.

Если мы видим трассировку стека -

...
Now releasing lock Thread-2
Exception in thread "Thread-2" java.lang.IllegalMonitorStateException
...
Now releasing lock Thread-4
Exception in thread "Thread-4" java.lang.IllegalMonitorStateException
...

Более очевидно, что потоки, которые не могут получить блокировку, вызывают исключение при попытке ее снять.

Попробуйте сделать что-нибудь подобное, чтобы было понятнее.

    System.out.println("Thread "+ Thread.currentThread().getName() + " trying to Acquire lock");
    if (lock.tryLock()) {
        try {
            System.out.println("Lock acquired .. ");
            int time=new Random().nextInt(10)+3;
            System.out.println("Thread " + Thread.currentThread().getName() + " Acquired lock for " + time + " seconds.");
            TimeUnit.SECONDS.sleep(time);
       } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
      }
        finally {
            System.out.println("Now releasing lock "+Thread.currentThread().getName());
            lock.unlock();
        }
    } else {
        System.out.println("Thread "+ Thread.currentThread().getName()+ " Failed to acquire lock .. ");
    }

Вызов tryLock() просто возвращает логическое значение, оно "не имеет отношения" к тому, будет ли выполняться следующая строка/инструкция, если таковая имеется, или нет. Это причина, почему tryLock() следует использовать в качестве проверки для выполнения некоторых действий/блоков кода, которые нужно синхронизировать. Надеюсь это ответит на твой вопрос.