添加第一个元素或删除最后一个元素时触发事件的设置

Question

I've got an API that allows users to listen to network events. I want to initiate a network connection when the first event listener is added, and disconnect when the last listener is removed.

Properties:

• The set (of listeners) is read much more often than written to.
• I need to be able to modify and read the set concurrently from multiple threads.
• I need to fire an event when the first element is added (connect to the network), and when the last element is removed (disconnect from the network).

What I've looked at so far:

• CopyOnWriteArraySet : thread-safe set that is optimized for reading more frequently than writing. There is no mechanism for running an operation when the first element is added or last one is removed.
• Phaser : fires an event when the last element is removed, but not when the first one is added. I guess I could use two Phasers to achieve this behavior but it seems wasteful.

Answer 1

Maybe ReadWriteLock is good for you?

A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing. The read lock may be held simultaneously by multiple reader threads, so long as there are no writers. The write lock is exclusive.

Simple example (i use hashmap instead set):

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class LockWrapper {

private final ReadWriteLock readWriteLock;
private final Map<Integer, Object> map;
private final EventSender sender;

public LockWrapper(EventSender eventSender) {
    map = new HashMap<>();
    readWriteLock = new ReentrantReadWriteLock();
    sender = eventSender;
}

public void add(Object o) {
    readWriteLock.writeLock().lock();
    try {
       if (map.isEmpty()) {
          sender.send("First add");
       }
       map.put(o.hashCode(), o); // for example using hashcode for key
    }
    finally {
       readWriteLock.writeLock().unlock();
    }
}

public void remove(Object o) {
    readWriteLock.writeLock().lock();
    try {
      map.remove(o.hashCode());

      if (map.isEmpty()) {
         sender.send("remove last");
      }
    }
    finally {
      readWriteLock.writeLock().unlock();
    }  
}

public Object read(int key) {
    readWriteLock.readLock().lock();
    try {
      Object object = map.get(key);
    } 
    finally {
      readWriteLock.readLock().unlock();
    }  
    return object;
}}