同时填充线程安全的Set

Question

Assuming I have a thread-safe collection, for which I would populate in the following manner:

   Set set = new HashSet();
   for (Map map : maps) {
        set.addAll(doSomeExpensiveProcessing(map.keySet()));
    }

What would be the best way of performing this concurrently? (ie each map would concurrently add its keys to the set.

EDIT - I'm aware HashSet is not thread-safe, but that would be outside the scope of the question, as far I'm concerned.

EDIT2 - It was correctly pointed that for this particular scenario concurrency will not reap huge benefits, but there will be additional steps, which I've now included in the code example.

Answer 1

This should work:

// NB - Be sure to use a concurrent form of Set here.
Set set = new HashSet();
ArrayList<Map> maps = new ArrayList<>();

public void test() {
  for (final Map map : maps) {
    new Thread(new Runnable() {
      @Override
      public void run() {
        set.addAll(map.keySet());
      }
    }).start();
  }
}

I realise you are not interested in the implementation of a HashSet that is concurrent but for completeness I would like to mention the options.

You could consider a ConcurrentSkipListSet if your objects implement Comparable , alternatively a Collections.newSetFromMap(new ConcurrentHashMap<Object,Boolean>()) would do.

Answer 2

While @OldCurmudgeon has a nice basic approach, in more serious code you probably want to make a Callable that does the expensive processing of the keys, and returns a new Collection . That can be combined with an Executor and/or a CompletionService. You don't even need a concurrent collection at the end.

eg, if the keys are Strings

public class DoesExpensiveProcessing implements Callable<Set<String>> {

   final Set<String> inKeys;

   public DoesExpensiveProcessing(Set<String> keys) {
     this.inKeys = keys;  // make a defensive copy if required...
   }

   public Set<String> call() {
      // do expensive processing on inKeys and returns a Set of Strings
   }
}

At this point you don't even need a parallel collection

List<DoesExpensiveProcessing> doInParallel = new ArrayList<DoesExpensiveProcessing>();
for (Map map : maps) {
   doInParallel.add(new DoesExpensiveProcessing(map.keySet()));
}

Set theResultingSet = new HashSet<String>();
List<Future<Set<String>>> futures = someExecutorService.invokeAll(doInParallel);
for (Future<Set<String>> f : futures) {
  theResultingSet.addAll(f.get());
}

Answer 3

That way it would not be concurrently, but at least threadsafe:

Set set = Collections.synchronizedSet(new HashSet());
...
// in some other threads:
for (Map map : maps) {
  set.addAll(map.keySet());
}

Or do you prefer something like the following:

ConcurrentMap<Object, Boolean> set = new ConcurrentHashMap<Object, Boolean>();
...
// in some other threads:
for (Map map : maps) {
  for (Object o : map.keySet()) {
    set.putIfAbsent(o, true);
  }
}