结构如何正确通知事件相关的其他线程？

Question

I'm trying to write a threadsafe structure to keep key - value pairs and to automatically remove them after certain time delay. The problem is, that the container should notify other threads about deletion.

I've also tried to use notifyAll() in a synchronized block, but the problem persists.

import java.util.Objects;
import java.util.concurrent.*;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;
import java.util.stream.Stream;


class Container <K extends Comparable<K>, V> {
    private ConcurrentHashMap <K, V> a;
    private final int delay = 2;
    private final Lock lock = new ReentrantLock();
    private final Condition removed = lock.newCondition();

    public Container() {
        a = new ConcurrentHashMap<>();
    }
    public synchronized void put(K k, V o) {
            lock.lock();
            a.put(k, o);
            new Thread(() -> {
                try {
                    TimeUnit.SECONDS.sleep(delay);


                    a.remove(k, o);
                    removed.signalAll();
                    lock.unlock();
                } catch (InterruptedException e){
                    e.printStackTrace();
                }

            }).start();

    }

    public  V get(int k)  {

        return a.get(k);
    }

    @Override
    public String toString() {
        return Stream.of(a)
        .filter(Objects::nonNull)
                .map(Object::toString)
                .collect(Collectors.joining(", ", "{", "}"));

    }
}

public class Main {

    public static void main(String [] args) throws InterruptedException {
        Container<Integer, Integer> c = new Container<>();
        c.put(0, 10);
        System.out.println(c);
        c.put(1, 11);
        c.put(2, 12);

        TimeUnit.SECONDS.sleep(3);
        System.out.println(c);

    }
}

Program finishes with code 0 and prints expected values: first element and the empty structure. But in either way I got the IllegalMonitorStateException .
Any thoughts, thanks.

Answer 1

public synchronized void put(K k, V o) {
    a.put(k, o);
    new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(delay);
            lock.lock();
            a.remove(k, o);
            removed.signalAll();
            lock.unlock();
        } catch (InterruptedException e){
            e.printStackTrace();
        }

    }).start();

}

Try this maybe. You re locking the lock and unlocking the lock in different threads. The thread that call theput method is the one using lock.lock() so it is the only one that can unlock it. The code inside the new Thread(....) belong to another thread so calling lock.unlock() there will not work. Also in the current code I don't see any use of the lock and condition, you can just remove all this (unless you plan on using it somewhere else we don't see), you can put and remove from a concurrent map with worrying about managing the access yourself.

Answer 2

In order to wait or notify ( await and signal if using Condition ) the thread, which performs an action, must own the lock it's trying to wait or notify on.

From your example: you put a lock in the main thread ( lock.put() ), then start a new thread. The new thread does not own the lock (it's still held by the main thread), but despite that you try to invoke signalAll() and get IllegalMonitorStateException .

In order to fix the problem you should:
1. Release the lock the main thread holds when it's ready (you never release it at the moment).
2. Lock in the new thread first and only then call signalAll()
3. Release the lock in the new thread when you're ready. Do it in the finally clause of the try-catch block to guarantee that the lock gets released in case of an exception.

Also a few moments:
- in order to be notified a thread must be waiting for notification.
- synchronization on the put() method is redundant, since you're already using a ReentrantLock inside.

Answer 3

We have a few things to look at here:

1. lock
2. removed which is a condition created using lock

Your main thread acquires a lock on lock in the put method. However it never releases the lock; instead it creates a new Thread that calls removed.signalAll() . However this new thread does not hold a lock lock which would be required to do this.

I think what you need to do is to make sure that every thread that locks lock also unlocks it and that every thread calling signalAll also has a lock.

  public synchronized void put(K k, V o) {

    a.put(k, o);

    new Thread(() -> {
      try {
        TimeUnit.SECONDS.sleep(delay);

        lock.lock(); // get control over lock here
        a.remove(k, o);
        removed.signalAll();
        lock.unlock();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

    }).start();

  }