用Java形成与谓词集合匹配的对象集合的最快方法是什么？

Question

Consider a collection of objects and a collection of predicates, whats the fastest way to form a collection of predicates object pairs, where each pair is an object and a predicate which returns true.

Also objects must be unique across pairs, but this does not apply to predicates.

Ie consider objects A, B, and C, and predicates P1, P2, P3

(A,P1),(B,P1),(C,P2) is a valid set of pairs, however (A,P1),(A,P1),(C,P2) is a not valid as there are duplicate objects across pairs

So once a predicate is matched to an object it effectively owns it.

Ie whats the fastest way to implement the method below given the constraints above:

Collection<Pair<Object,Predicate<Object>> getAllMatches(Collection<Object> objects, Collection<Predicate<Object>>);

where Pair is:

class Pair<A,B> {
    A a;
    B b;
}

I know I'd need to use multi-threading but I'm not sure of the best strategy or the best collection implementations to use. Also I imagine the uniqueness contraint will introduce contention due to the need for some sort of locking or ownership mechanism.

Heres my attempt, it seems to basic, surely there must be a faster way:

  Collection<Pair<Object,Predicate> getAllMatches(BlockingQueue<Object> objects, Collection<Predicate> predicates){
List<Callable<Pair>> callables = new ArrayList<>();
for (Object o : objects){
    Callable<Pair> c = ()-> {
        Object polled = objects.take();
        for (Predicate p : predicates){
            if (p.test(polled)){
                return new Pair<Object,Predicate>(o,p);
            }
        }
        objects.put(o);
        return null;
    }
    callables.add(c);
}
List<Future<Pair>> futurePairs = exectors.invokeAll(callables);

 // return pairs
}

Answer 1

Your benchmark should absolutely be:

final Collection<Pair<Object, Predicate>> getMatches(
        final Collection<Object> objects, 
        final Collection<Predicate> predicates) {
    final Set<Pair<Object, Predicate>> matches = new HashSet<>();
    for (Object o : objects) {
        for (Predicate p : predicates) {
            if (p.test(o)) {
                matches.add(Pair.with(o, p));
                break;
            }
        }
    }
    return matches;
}

Sequential execution is often fastest. It may seem counter-intuitive - running tests on multiple cores should be fastest - but for many operations, your bottleneck is actually going to be memory-access. Each processor is going to stall, doing nothing, while it verifies that it's processor-level-cache is consistent with all of the other processors' caches.

I'd propose testing something like this, if you're confident that multithreading is going to save you some time:

final Collection<Pair<Object, Predicate>> getMatches(
        final Collection<Object> objects, 
        final Collection<Predicate> predicates) {
    final List<Future<Pair<Object,Predicate>>> futures = new ArrayList<>();
    for (final Object o : objects) {
        futures.add(executorService.invoke(() -> {
            for (Predicate p : predicates) {
                if (p.test(o)) {
                    return Pair.with(o, p);
                }
            }
            return null;
        });
    }
    final Collection<Pair<Object,Predicate>> matches = new ArrayList<>(futures.size());
    for (final Future<Pair<Object,Predicate>> future : futures) {
        final Pair<Object,Predicate> pair = future.get();
        if (pair != null) {
            matches.add(pair);
        }
    }
    return matches;
}

None of the threads write to shared memory, so there is no lock-contention to worry about.

Answer 2

I think you might be overcomplicating this a bit. Stream over objects and for each object find a predicate that matches it:

objects.stream()    // or parallelStream() for multithreaded
    .distinct()     // can omit this if uniqueness of objects is enforced elsewhere
    .flatMap(obj -> predicates.stream()
        .filter(p -> p.test(obj))
        .map(p -> new Pair<>(obj, p))
        .limit(1)   // one predicate per object
    ).collect(toList());

Answer 3

A short solution with Java8 streams using declarative parallelism:

Collection<Pair<Object, Predicate<Object>>> getAllMatches(Set<Object> objects, Set<Predicate<Object>> predicates) {
    List<Pair<Object, Predicate<Object>>> pairs = predicates.parallelStream()
        .map(predicate -> new Pair<>(objects.stream().filter(predicate), predicate))
        .flatMap(pair -> pair.a.map(a -> new Pair<>(a, pair.b)))
        .collect(toList());
    return pairs;
}

Parallel execution is managed by the stream:

    List<Pair<Object, Predicate<Object>>> pairs = predicates.parallelStream()

The next line creates a Pair (the stream contains all matching objects):

        .map(predicate -> new Pair<>(objects.stream().filter(predicate), predicate))

The next line flattens to Pair:

        .flatMap(pair -> pair.a.map(a -> new Pair<>(a, pair.b)))

The last line creates the final collection:

        .collect(toList());

If objects or predicates are not free of duplicates, put .distinct() behind stream() or parallelStream() .