Question

我希望有一些类似于Collectors.maxBy()的东西，一个收集器，它可以获取集合中的顶级元素（maxBy只获得一个）。

我有一组Possibility个对象，可以使用Integer score(Possibility)方法进行评分。

首先我尝试了：

List<Possibity> possibilities = getPossibilityStream()
    .parallel()
    .collect(Collectors.toList());

if(!possibilities.isEmpty()) {
    int bestScore = possibilities.stream()
        .mapToInt(p -> score(p))
        .max()
        .getAsInt();
    possibilities = possibilities.stream()
        .filter(p -> score(p)==bestScore)
        .collect(Collectors.toList());
}

但是这样做，我扫描了三次。一旦建立它，第二次获得最高分，第三次过滤它，这不是最佳的。此外，可能性的数量可能很大（> 10 ¹²）。

最好的方法应该是直接获得第一个收集中的顶级可能性，但似乎没有内置的收集器来做这样的事情。

所以我实现了自己的Collector：

public class BestCollector<E> implements Collector<E, List<E>, List<E>> {

    private final Comparator<E> comparator;

    private final Class<? extends List> listImpl ;

    public BestCollector(Comparator<E> comparator, Class<? extends List> listImpl) {
        this.comparator = comparator;
        this.listImpl = listImpl;
    }

    public BestCollector(Comparator<E> comparator) {
        this.comparator= comparator;
        listImpl = ArrayList.class;
    }

    @Override
    public Supplier<List<E>> supplier() {
        return () -> {
            try {
                return listImpl.newInstance();
            } catch (InstantiationException | IllegalAccessException ex) {
                throw new RuntimeException(ex);
            }
        };
    }

    @Override
    public BiConsumer<List<E>, E> accumulator() {
        return (list, e) -> {
            if (list.isEmpty()) {
                list.add(e);
            } else {
                final int comparison = comparator.compare(list.get(0), e);
                if (comparison == 0) {
                    list.add(e);
                } else if (comparison < 0) {
                    list.clear();
                    list.add(e);
                }
            }
        };
    }

    @Override
    public BinaryOperator<List<E>> combiner() {
        return (l1, l2) -> {
            final int comparison = comparator.compare(l1.get(0), l2.get(0));
            if (comparison == 0) {
                l1.addAll(l2);
                return l1;
            } else if (comparison < 0) {
                return l2;
            } else {
                return l1;
            }
        };
    }

    @Override
    public Function<List<E>, List<E>> finisher() {
        return Function.identity();
    }

    @Override
    public Set<Characteristics> characteristics() {
        return EnumSet.of(Characteristics.IDENTITY_FINISH, Characteristics.CONCURRENT, Characteristics.UNORDERED);
    }
}

然后：

List<Possibity> possibilities = getPossibilityStream()
    .parallel()
    .collect(new BestCollector<Possibility>((p1, p2) -> score(p1).compareTo(score(p2)));

这可以在顺序模式下完成（没有.parallel()），但在并行模式下偶尔有两个例外：

行中的java.lang.IndexOutOfBoundsException Index: 0, Size: 0：
```
final int comparison = comparator.compare(list.get(0), e);
```

accumulator()方法的

我理解在list.clear()和list.isEmpty()之间调用list.get(0)时会发生这种情况。

得分（可能性）方法中的java.lang.NullPointerException，因为可能性为null。同样涉及同一行：
```
final int comparison = comparator.compare(list.get(0), e);
```

我不明白list.get(0)如何返回null ...

在并行模式下，有时list.get(0)会引发IndexOutOfBoundsException，有时会返回null。

我知道我的代码不是线程安全的，所以我尝试了几种解决方案：

在BestCollector的所有方法中添加synchronized：public synchronized …
使用线程安全集合而不是ArrayList：java.util.concurrent.CopyOnWriteArrayList
添加synchronized并同时使用CopyOnWriteArrayList

从Characteristics.CONCURRENT方法的Set<Characteristics>中删除characteristics()

@Override
public Set<Characteristics> characteristics() {
    return EnumSet.of(Characteristics.IDENTITY_FINISH, Characteristics.UNORDERED);
}

但我不知道Characteristics.CONCURRENT是否在这里表明我的代码是线程安全的，或者我的代码将用于并发处理。

但这些解决方案都没有解决问题。

事实上，当我从特征中移除CONCURRENT时，有时会有一个java.lang.IndexOutOfBoundsException: Index: 0, Size: 0但是在行中：

final int comparison = comparator.compare(l1.get(0), l2.get(0));

combiner()方法的

。

但是，accumulator()方法引发的异常似乎不再发生了。

@ Holger的答案是对的。

完整的解决方案是更改combiner()和characteristics()方法：

@Override
public BinaryOperator<List<E>> combiner() {
    return (l1, l2) -> {
        if (l1.isEmpty()) {
            return l2;
        } else if (l2.isEmpty()) {
            return l1;
        } else {
            final int comparison = comparator.compare(l1.get(0), l2.get(0));
            if (comparison == 0) {
                l1.addAll(l2);
                return l1;
            } else if (comparison < 0) {
                return l2;
            } else {
                return l1;
            }
        }
    };
}

@Override
public Set<Characteristics> characteristics() {
    return EnumSet.of(Characteristics.IDENTITY_FINISH, Characteristics.UNORDERED);
}

Answer 1

您的代码只有一个重大错误：如果您的收集器不是线程安全的，它不应该报告Characteristics.CONCURRENT，因为它确实声称它是线程安全的。

您必须要了解的重点是，对于非CONCURRENT收集器，框架将执行必要的步骤，以线程安全但仍然有效的方式使用它：

对于每个工作线程，将通过supplier()
每个工作人员将使用accumulator()函数及其自己的本地容器
一旦两个工作线程完成工作，combiner()将被使用
所有工作线程完成工作且所有容器合并后，将使用finisher()

所以你要做的就是确保你的供应商真正在每次调用中返回一个新实例，并且所有函数都是非干扰和无副作用的（除了他们作为参数接收的容器之外的其他任何东西），当然，当收集器不是并发收集器时，不要报告Characteristics.CONCURRENT。

此处不需要synchronized关键字和并发集合。

顺便说一下，Comparator形式的(p1, p2) -> score(p1).compareTo(score(p2))可以使用Comparator.comparing(p -> score(p))实现，或者如果得分值为int：Comparator.comparingInt(p -> score(p))。< / p>

最后，您的组合器功能不会检查其中一个列表是否为空。这完美地解释了IndexOutOfBoundsException中的combiner，而IndexOutOfBoundsException中的accumulator是收集者报告的结果Characteristics.CONCURRENT ...

了解向synchronized或accumulator()方法添加combiner()关键字并不保护通过lambda表达式构造的函数也很重要。它将保护构造函数实例的方法，但不保护函数的代码本身。与内部类相比，无法在实际函数的实现方法中添加synchronized关键字。

如何实现线程安全的收集器？

1 个答案: