Akka流-并行可运行图

需要建议，我需要并行运行多个源图，例如，我创建了这个示例代码，其中我创建了10个图并并行运行它们

这是正确的方法还是应该在一个图中创建多个源并在一个图中并行运行它们

def createGraph(start: Int, end: Int, name: String) = {
  RunnableGraph.fromGraph(GraphDSL.create() {
    implicit builder =>
      import GraphDSL.Implicits._
      val s = Source(start to end)
      val f = Flow[Int].map[String](x => x.toString)
      val sink = Sink.foreach[String](x => println(name + ":" + x))

      val t = builder.add(s)

      val flow1 = builder.add(f)

      t ~> flow1 ~> sink

      ClosedShape
  })
}


(1 to 10).map(x => createGraph(x, x + 10, "g" + x)).map(_.run())

谢谢 Arun

< P>我尝试使用并行，这看起来不错，我的源不同，但流和汇是相同的。每个源是在下面的例子中的模拟，考虑它们就像你正在从一些外部源读取流：

object TestParallelGraph extends App {

  implicit val system = ActorSystem("test")
  implicit val dispacher = system.dispatcher
  implicit val materializer = ActorMaterializer()

  val listOfDifferentSource=List(1,2,3) //consider we have to read data from various sources


 def createGraph() = {
    RunnableGraph.fromGraph(GraphDSL.create() {
      implicit builder =>
        import GraphDSL.Implicits._

        val merge=builder.add(Merge[Int](listOfDifferentSource.length))

        val flow=builder.add(Flow[Int].map(_ + 10)) //just random flow to add 10

        //again as mentioned above creating source with different information to simulate
        Source(listOfDifferentSource.head*100 to 100* listOfDifferentSource.head+10) ~> merge ~> flow ~> Sink.foreach(println)

        for{
          i <- listOfDifferentSource.tail //for each other source
        }yield (Source(100*i to 100*i+10) ~> merge) 

        ClosedShape
    })
  }

  createGraph().run()
}

objecttestparallegraph扩展应用程序{
隐式val系统=ActorSystem（“测试”）
隐式val dispatcher=system.dispatcher
隐式val-materializer=actormatarializer（）
val listOfDifferentSource=List（1,2,3）//考虑我们必须从各种源读取数据
def createGraph（）={
RunnableGraph.fromGraph（GraphDSL.create（））{
隐式生成器=>
导入GraphDSL.Implicits_
val merge=builder.add（merge[Int]（listOfDifferentSource.length））
val flow=builder.add（flow[Int].map（+10））//只需随机流添加10
//同样如上所述，使用不同的信息创建源以进行模拟
Source（listOfDifferentSource.head*100到100*listOfDifferentSource.head+10）~>merge~>flow~>Sink.foreach（println）
为了{
i合并）
封闭形状
})
}
createGraph（）.run（）
}
< /代码> 我尝试使用并行性，这看起来不错，我的源不同，但流和汇是相同的。每个源是在下面的例子中的模拟，把它们看作是从外部源读取流：

object TestParallelGraph extends App {

  implicit val system = ActorSystem("test")
  implicit val dispacher = system.dispatcher
  implicit val materializer = ActorMaterializer()

  val listOfDifferentSource=List(1,2,3) //consider we have to read data from various sources


 def createGraph() = {
    RunnableGraph.fromGraph(GraphDSL.create() {
      implicit builder =>
        import GraphDSL.Implicits._

        val merge=builder.add(Merge[Int](listOfDifferentSource.length))

        val flow=builder.add(Flow[Int].map(_ + 10)) //just random flow to add 10

        //again as mentioned above creating source with different information to simulate
        Source(listOfDifferentSource.head*100 to 100* listOfDifferentSource.head+10) ~> merge ~> flow ~> Sink.foreach(println)

        for{
          i <- listOfDifferentSource.tail //for each other source
        }yield (Source(100*i to 100*i+10) ~> merge) 

        ClosedShape
    })
  }

  createGraph().run()
}

objecttestparallegraph扩展应用程序{
隐式val系统=ActorSystem（“测试”）
隐式val dispatcher=system.dispatcher
隐式val-materializer=actormatarializer（）
val listOfDifferentSource=List（1,2,3）//考虑我们必须从各种源读取数据
def createGraph（）={
RunnableGraph.fromGraph（GraphDSL.create（））{
隐式生成器=>
导入GraphDSL.Implicits_
val merge=builder.add（merge[Int]（listOfDifferentSource.length））
val flow=builder.add（flow[Int].map（+10））//只需随机流添加10
//同样如上所述，使用不同的信息创建源以进行模拟
Source（listOfDifferentSource.head*100到100*listOfDifferentSource.head+10）~>merge~>flow~>Sink.foreach（println）
为了{
i合并）
封闭形状
})
}
createGraph（）.run（）
}
为什么所有这些代码都等效于：Source（从开始到结束）.map（u.toString）.runForeach（x=>println（s“$name:$x”））我从主代码中提取了一些复杂的流处理来维护知识产权。问题是，如果我有多个源信息，并且需要为每个源运行图形，那么什么是最佳实践。例如，我们可以考虑多个源，也可以考虑阅读多个卡夫卡主题、转换、处理和接收这个方法对我来说有点奇怪，虽然我不能很好地指出原因。我会把时间分开，让事情成为它们自己的阶段，然后使用合并和/或平衡将它们连接在一起，形成一个单独的图。然后运行一个图，只运行一次。现在你正在创建n个“孤岛”。为什么所有的代码都要做：源代码（从开始到结束）.map（u.toString）.runForeach（x=>println（s“$name:$x”））我从主代码中提取了一些复杂的流处理来维护知识产权。问题是，如果我有多个源信息，并且需要为每个源运行图形，那么什么是最佳实践。例如，我们可以考虑多个源，也可以考虑阅读多个卡夫卡主题、转换、处理和接收这个方法对我来说有点奇怪，虽然我不能很好地指出原因。我会把时间分开，让事情成为它们自己的阶段，然后使用合并和/或平衡将它们联系在一起，形成一个单独的图形。然后运行一个图形，只运行一次。现在你正在创建n个“孤岛”。请注意，这不是并行运行，而是按顺序运行，您需要使用
.async
标记异步边界，如您链接到的文档中所述。谢谢john。我使用的是kaka stream和http实验2.0.3，因此我认为mapAsync应该注意这一点。我的代码将成为val flow=builder.add（flow[Int].mapAsync（平行度=10）（u10））为同一个注释添加了代码，注意这不是并行运行而是顺序运行的，您需要使用
.async
标记异步边界，如您链接到的文档中所述。谢谢john。我正在使用kaka stream和http实验2.0.3，因此我认为mapAsync应该注意这一点。我的代码将成为val flow=builder.add（flow[Int].mapsync（parallelism=10）（uz+10））添加了相同的代码