线程安全查找和从集合中删除对象

Question

I wonder how can I do something like the following

class MyCollection<E> implements Collection<E> {
    @Nullable E findAndRemove(Predicate<E> predicate) {
        for (E e : this) {
            if (predicate.test(e)) {
                remove(e);
                return e;
            }
        }
        return null;
    }   
}

in a thread-safe manner. It doesn't really have to be a Collection , as the only needed operations are add and findAndRemove . Note that

• removeIf is unrelated as it removes all matching elements and gives nothing in return
• let's assume that synchronization isn't good enough
• CopyOnWriteArrayList might do, but it's Javadoc says "efficient when ... traversal operations vastly outnumber mutations", which definitely isn't true here
• it's not allowed to return the same element twice (unless re-added in the meantime), which could easily happen when using CopyOnWriteArrayList naively
• which matching element gets returned doesn't matter

Concerning premature optimization and XY problem: Yes, I know! I went into this when fooling around with something I may or mayn't need one day, but I find this problem interesting per se.

Answer 1

Since you only need the add and findAndRemove methods, some type of concurrent hash is a natural choice, as there has been a good implementation ( ConcurrentHashMap ) since Java 1.5. Now since we don't actually need a Map but rather a Set we can just use (since Java 8 anyway) ConcurrentHashMap.newKeySet() to create a concurrent set using the same implementation as the concurrent map.

Then, given a concurrent set, we can pretty much use your loop above, and optimistically remove the element, and then simply continue searching on failure (which means that a thread concurrently removed the element that matched):

class MyCollection<E> {

  private Set<E> underlying = ConcurrentHashMap.newKeySet();

  void add(E elem) {
    underlying.add(elem);
  }

  @Nullable E findAndRemove(Predicate<E> predicate) {
    for (E e : underlying) {
        if (predicate.test(e) && remove(e)) {
          return e;
        }
    }
    return null;
  }   
}

The only real change with respect to your example code is that we check the result of Set.remove() to see if the element was actually removed. For the concurrent set, this works "safely" - ie, only the thread which actually removed the object will see true , so this set will correctly return the element only if it was actually removed, and no other thread will then be able to return that element.

It should satisfy all your requirements and perform as well as the underlying concurrent map implementations, which on modern JDKs is "very well".

Note that the use of a Set implies that duplicate elements aren't allowed. It wasn't clear from your description whether you planned to support duplicates or not, but if you did, you could use the same approach built on a concurrent multimap ¹ , or simply using ConcurrentHashMap<E, AtomicInteger> , where the AtomicInteger value a reference count of the number of elements with the same key, the add and findAndRemove methods manipulate the reference count ² .

---

¹ In a quick search, however, I couldn't find an obvious open source implementation of a concurrent multimap. Note that you don't actually need a capital-M Multimap implementation with all its functionality - you really only need "some multiset" with the ability to add an element, iterate over available elements, and "remove" an element (ie, decrement its refcount in the set).

² I'm actually glossing over a few details of the reference counted implementation since in this case there is a possible race between the thread that decrements the refcount to zero and any thread calling add for the same element which may increment the refcount above zero (but the entry has already been removed). This can be avoided but I don't go into details yet since it isn't clear if you want to support duplicates.

Answer 2

您可以对集合中的变异使用读写锁定，也可以使用ConcurrentHashMap将集合表示为集合。

Set set =Collections.newSetFromMap(new ConcurrentHashMap<Object,Boolean>());