Java 广播的反面

我可以创建一个源，它有整数{1，2，3}，使用广播它将创建N个源，每个源都有{1，2，3}

我想做相反的事情，我有N个源，每个源都应该提供完全相同的整数{1，2，3}，并且使用？？？我想创建一个源代码，它将有{1,2,3}

我会给我的手术打电话？？？因为“内爆”，我没有更好的名字

为了回答你脑海中浮现的明显问题：“为什么要做这种奇怪的事情，而不只是获取其中的任何一个来源”，我必须指出，这N个来源预计会提供相同的数据，但在实践中，有些可能根本没有回应。如果他们会用不同的数据来回应呢？这是违反我们业务逻辑的错误，所以抛出异常是可以的

例如： 我有两个整数源（A和B），它们都有{1,2,3}。现在我同时问他们两个整数。源B对整数1的响应速度比A快，因此作为内爆源的I立即对1进行响应（甚至不等待源A的回答）

现在我向两个源请求下一个元素，这次A用2更快地响应（我忽略了它是1），我不用等待B就返回2

现在我向两个源请求下一个元素，A抛出ConnectionLost，因为AsonException，但是B用3响应，所以内爆源返回3，一切正常

所以这里的优势是速度——我的内爆源和我聚合的最快源一样快，而且它保护我免受N-1个源的异常

最后，我尝试实现如下功能：

<T> Source<T, ?> implode(List<Source<T, ?>> sources);

震源内爆（列出震源）；

我得到的最接近的结果是使用Zip-wait等待来自所有N个源的结果，然后（通过使用我的函数）返回其中任何一个。它确实保护我不受异常的影响，但是它使我的速度和最慢的一样快，这不是我想要的

是否已经实施了类似我的“内爆”战略？如果是，它的名字是什么？如果没有，我自己应该如何实施

以下是我尝试过的：

class Multi
{   
    static <T> Source<T, ?> merger(List<Source<T, ?>> sources)
    {
        switch(sources.size())
        {
            case 0: throw new RuntimeException("No sources provided!");
            case 1: return sources.get(0);
            default: return Source.zipWithN(Multi::zip, sources);
        }
    }

    private static <T> T zip(List<T> list)
    {
        return list
            .stream()
            .reduce(Multi::same)
            .orElseThrow(RuntimeException::new);
    }

    private static <T> T same(T first, T second)
    {
        if(Objects.equals(first, second))
        {
            return first;
        }
        else
        {
            throw new RuntimeException();
        }
    }

    public static void main(String[] args)
    {
        Source<Integer, ?> source1 = Source.from(Arrays.asList(1, 2, 3, 4));
        Source<Integer, ?> source2 = Source.from(Arrays.asList(1, 2, 3));
        Source<Integer, ?> merger = merger(Arrays.asList(source1, source2));

        merger
            .runForeach(System.out::println, ActorMaterializer.create(ActorSystem.create()))
            .thenRun(() -> System.out.println("done"));
    }
}

多类
{   
静态源合并（列出源）
{
开关（sources.size（））
{
案例0：抛出新的RuntimeException（“未提供源代码！”）；
案例1：返回源。获取（0）；
默认值：return Source.zipWithN（Multi:：zip，sources）；
}
}
私有静态T-zip（列表）
{
返回列表
.stream（）
.reduce（多：：相同）
.orelsetrow（运行时异常：：新建）；
}
私有静态T相同（T第一，T第二）
{
if（Objects.equals（第一，第二））
{
先返回；
}
其他的
{
抛出新的RuntimeException（）；
}
}
公共静态void main（字符串[]args）
{
source1=Source.from（Arrays.asList（1,2,3,4））；
source2=Source.from（Arrays.asList（1,2,3））；
源合并=合并（Arrays.asList（source1，source2））；
合并
.runForeach（System.out:：println，ActorMaterializer.create（ActorSystem.create（）））
.然后运行（（）->System.out.println（“完成”）；
}
}

此代码输出：1 2 3完成

我想：1234完成

然而，我的zip方法只被调用了三次，所以我没有机会这么做。第二个问题是我等待所有源，而不是尽可能快地返回值。它涵盖了当值不同时引发异常的情况，因此

Source<Integer, ?> source1 = Source.from(Arrays.asList(1, 2, 4));
Source<Integer, ?> source2 = Source.from(Arrays.asList(1, 2, 3)); 

source1=Source.from（Arrays.asList（1,2,4））；
source2=Source.from（Arrays.asList（1,2,3））；

产出：1 2例外

---

正如预期的那样。

广播的反面是emit我在Akka中找不到名为“emit”的类/方法，所以我猜您指的是命名约定而不是解决方案？Merge：您会这么客气并提供最少的示例吗？