-------------------------------------------
Collezioni parallele Scala:

ParCollectionMain.scala:

___________________________________________
object ParCollectionMain extends App {
    val n = 7000000
    def isPrime(n:Int) =
        n>1 && (2 to Math.sqrt(n).toInt).forall(n % _ != 0)

    val s1 = System.nanoTime
    val r1 = (1 to n).map(isPrime).count(identity) // versione sequenziale
    println("Res: "+r1)
    println("Versione sequenziale: " + (System.nanoTime-s1)*1E-9)

    val s2 = System.nanoTime
    val r2 = (1 to n).par.map(isPrime).count(identity) // versione parallela (si noti il .par)
    println("Res: "+r2)
    println("Versione parallela: " + (System.nanoTime-s2)*1E-9)
}
___________________________________________


-------------------------------------------
Modello fork-join in Scala:

ForkJoinMain.scala:

___________________________________________
object ForkJoinMain extends App {
    def perdiTempo = while(true) {}

    val r = new Runnable{
        def run() = {
            // fai qualcosa 1...
            perdiTempo
        }
    }
    val t = new Thread(r)
    t.start()
    // fai qualcosa 2
    perdiTempo
    t.join()
}
___________________________________________

dove "fai qualcosa 1" e "fai qualcosa 2" vengono eseguiti da thread distinti.

-------------------------------------------
Costrutto par per l'esecuzione parallela di task:

Par.scala:

___________________________________________
object Par {
    def par(a: =>Unit)(b: =>Unit) = {
        val r = new Runnable {
            def run() = a
        }
        val t = new Thread(r)
        t.start()
        b
        t.join()
  }
}
___________________________________________

ParMain.scala:

___________________________________________
import Par._

object ParMain extends App {
    val n = 1e6
    par {
        var i = 0
        while(i<n) { i+=1 }
    }
    {
        par {
            var i = 0
            while(i<n) { i+=1 }
        }
        {
            var i = 0
            while(i<n) { i+=1 }
        }
    }
}
___________________________________________


-------------------------------------------
Esperimento race condition:

RaceMain.scala:

___________________________________________
import Par._

object RaceMain extends App {
    val n = 1e9
    var i: Long = 0
    var j: Long = 0
    var c: Long = 0
    par {
        while (i<n) {
            i += 1
            c += 1
        }
    } {
        while (j<n) {
            j += 1
            c -= 1
        }
    }
    println("c="+c+" i-j="+(i-j))
}
___________________________________________

c dovrebbe valere zero...