Gleichzeitige anzeigen/foreach in scala

Ich habe eine iteration vals: Iterable[T] und eine lang andauernde Funktion ohne relevante Nebenwirkungen: f: (T => Unit). Das ist im Augenblick angewendet, um vals in der offensichtlichen Weise:

vals.foreach(f)

Ich würde gerne die Aufrufe f zu tun, die gleichzeitig (innerhalb vernünftiger Grenzen). Ist es eine offensichtliche Funktion, die irgendwo in der Scala Basis-Bibliothek? So etwas wie:

Concurrent.foreach(8 /* Number of threads. */)(vals, f)

Während f ist ziemlich lange laufen, es ist kurz genug, dass ich nicht wollen, dass der overhead für den Aufruf einer thread für jeden Anruf, also ich bin auf der Suche nach etwas, das basierend auf einem thread-pool.

InformationsquelleAutor David Crawshaw | 2009-11-17
  1. 10

    Ich mag die Futures Antwort. Jedoch, während es parallel ausgeführt werden, wird es auch wieder asynchron, was wahrscheinlich nicht das, was Sie wollen. Der richtige Ansatz wäre wie folgt:

    import scala.actors.Futures._

vals map { x => future { f(x) } } foreach { _() }
    • Seien Sie vorsichtig, dass vals ist eine strenge Sammlung-wenn es faul ist (und in Scala 2.7 dieses umfasst die Range Klasse), die futures nicht erstellt werden, bis jeder einen benötigt foreach, und es wird nichts geschehen parallel.
    • Ich nehme an, wir könnten das problem lösen, indem Sie die Injektion einer anderen foreach Anruf zwischen der map und die aktuellen foreach. Also: vals map { x => future { f(x) } } foreach { x => x } foreach { _() }
    • Das wäre eine Karte, die wir haben, um zu injizieren, nicht anderen foreach? Und es ist mir nicht klar, dass der map-lazy-Kollektion ist streng. Der sicherste Weg ist zu nennen toArray.
    • Du hast Recht, foreach war (natürlich) die falsche Sache zu injizieren, da gibt es Unit. Mein schlechtes! 🙂 Die map Funktion auf lazy collections ist fast immer non-strict, so können wir entweder rufen toList (oder toArray), oder wir können das Projekt und dann force: (vals map { x => future { f(x) } } projection).force foreach { _() }. Ich weiß nicht, ob das besser als einfach toList, aber es ist sicherlich anders.
    • Was bedeutet es, wenn Sie sagen, es "gibt asynchron"? Bedeutet es, dass es nicht blockiert? (und warum sollte das ein problem sein?)
    • Jeder Einblick, was zu verwenden, jetzt, Bibliothek ist veraltet?

    InformationsquelleAutor Daniel Spiewak
  2. 17

    Viele der Antworten von 2009 noch die alte scala.Akteure.Futures._, die sind nicht mehr in den neueren Scala. Während Akka ist der bevorzugte Weg, ein viel mehr lesbar ist, verwenden Sie einfach parallel (.par) Sammlungen:

    vals.foreach { v => f(v) }

    wird

    vals.par.foreach { v => f(v) }

    Alternativ mit parMap erscheinen kann, kurz und bündig, wenn auch mit der Einschränkung, dass Sie sich merken müssen, importieren Sie die üblichen Scalaz*. Wie üblich, gibt es mehr als einen Weg, um das gleiche zu tun in der Scala!!

    • Dies sollte jetzt die akzeptierte Antwort
    InformationsquelleAutor Kei-ven
  3. 13

    Scalaz hat parMap. Sie würde es verwenden, wie folgt:

    import scalaz.Scalaz._
import scalaz.concurrent.Strategy.Naive

    Dieser Ausrüstung jeder Funktor (einschließlich Iterable) mit einem parMap Methode, so können Sie nur:

    vals.parMap(f)

    Erhalten Sie auch parFlatMap, parZipWith usw.

    InformationsquelleAutor Apocalisp
  4. 3

    Hatte ich einige Probleme mit scala.Akteure.Futures in Scala 2.8 (es war buggy, wenn ich überprüft). Mit java-libs direkt für mich gearbeitet, obwohl:

    final object Parallel {
  val cpus=java.lang.Runtime.getRuntime().availableProcessors
  import java.util.{Timer,TimerTask}
  def afterDelay(ms: Long)(op: =>Unit) = new Timer().schedule(new TimerTask {override def run = op},ms)
  def repeat(n: Int,f: Int=>Unit) = {
    import java.util.concurrent._
    val e=Executors.newCachedThreadPool //newFixedThreadPool(cpus+1)
    (0 until n).foreach(i=>e.execute(new Runnable {def run = f(i)}))
    e.shutdown
    e.awaitTermination(Math.MAX_LONG, TimeUnit.SECONDS)
  }
}
    InformationsquelleAutor Jonathan Graehl
  5. 2

    Ich würde verwenden scala.actors.Futures:

    vals.foreach(t => scala.actors.Futures.future(f(t)))
    InformationsquelleAutor Daniel C. Sobral
  6. 2

    Die neueste Version von Funktionale Java hat einige höher -, um concurrency-features, die Sie verwenden können.

    import fjs.F._
import fj.control.parallel.Strategy._
import fj.control.parallel.ParModule._
import java.util.concurrent.Executors._

val pool = newCachedThreadPool
val par = parModule(executorStrategy[Unit](pool))

    Und dann...

    par.parMap(vals, f)

    Erinnern zu shutdown die pool.

    InformationsquelleAutor Apocalisp
  7. 0

    Können Sie die Parallel Sammlungen aus der Scala-standard-Bibliothek.
    Sie sind genauso wie normale Sammlungen, aber Ihre Operationen parallel ausführen. Sie müssen nur ein par rufen Sie vor dem Aufruf einige Sammlungen Betrieb.

    import scala.collection._

val array = new Array[String](10000)
for (i <- (0 until 10000).par) array(i) = i.toString
    InformationsquelleAutor Roland
Schreibe einen Kommentar