Scala: Par

// 1. let's test usual List
object Main extends App {
  val lst = List(1, 2, 3, 4, 5, 6, 7, 8)

  println(LocalDateTime.now() + ": Hello!")
  val result = lst map { item =>
    Thread.sleep(3000)
    val n = item * 10
    println(LocalDateTime.now() + ": " + n)
    n
  }
  println(LocalDateTime.now() + ": Bye! " + result)
}

        // Output (look at seconds):
        // 2018-01-15T21:46:39.235: Hello!
        // 2018-01-15T21:46:42.241: 10
        // 2018-01-15T21:46:45.242: 20
        // 2018-01-15T21:46:48.242: 30
        // 2018-01-15T21:46:51.242: 40
        // 2018-01-15T21:46:54.242: 50
        // 2018-01-15T21:46:57.242: 60
        // 2018-01-15T21:47:00.242: 70
        // 2018-01-15T21:47:03.243: 80
        // 2018-01-15T21:47:03.243: Bye! List(10, 20, 30, 40, 50, 60, 70, 80)

// 2. now make it parallel! My system has 8-cores processor:
object Main extends App {
  val lst = List(1, 2, 3, 4, 5, 6, 7, 8)
  val plst: ParSeq[Int] = lst.par // !!!

  println(LocalDateTime.now() + ": Hello!")
  val result = plst map { item =>
    Thread.sleep(3000)
    val n = item * 10
    println(LocalDateTime.now() + ": " + n)
    n
  }
  println(LocalDateTime.now() + ": Bye! " + result)
}

        // Output:
        // 2018-01-15T21:49:10.999: Hello!
        // 2018-01-15T21:49:14.047: 20
        // 2018-01-15T21:49:14.047: 30
        // 2018-01-15T21:49:14.047: 80
        // 2018-01-15T21:49:14.047: 60
        // 2018-01-15T21:49:14.047: 10
        // 2018-01-15T21:49:14.047: 70
        // 2018-01-15T21:49:14.047: 50
        // 2018-01-15T21:49:14.048: 40
        // 2018-01-15T21:49:14.051: Bye! ParVector(10, 20, 30, 40, 50, 60, 70, 80)

// 3. what if a collection would be larger than cores count?
val lst = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

        // Output:
        // 2018-01-15T21:52:39.112: Hello!
        // 2018-01-15T21:52:42.151: 70
        // 2018-01-15T21:52:42.151: 20
        // 2018-01-15T21:52:42.151: 80
        // 2018-01-15T21:52:42.151: 10
        // 2018-01-15T21:52:42.151: 40
        // 2018-01-15T21:52:42.151: 110
        // 2018-01-15T21:52:42.151: 50
        // 2018-01-15T21:52:42.151: 100
        // 2018-01-15T21:52:45.152: 120
        // 2018-01-15T21:52:45.152: 90
        // 2018-01-15T21:52:45.152: 60
        // 2018-01-15T21:52:45.152: 30
        // 2018-01-15T21:52:45.156: Bye! ParVector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120)

// 4. are they scaled evenly?
val lst = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)

        // Output:
        // 2018-01-15T21:55:21.230: Hello!
        // 2018-01-15T21:55:24.270: 150
        // 2018-01-15T21:55:24.270: 130
        // 2018-01-15T21:55:24.270: 10
        // 2018-01-15T21:55:24.270: 30
        // 2018-01-15T21:55:24.270: 90
        // 2018-01-15T21:55:24.270: 70
        // 2018-01-15T21:55:24.270: 20
        // 2018-01-15T21:55:24.270: 50
        // 2018-01-15T21:55:27.270: 100
        // 2018-01-15T21:55:27.270: 80
        // 2018-01-15T21:55:27.270: 60
        // 2018-01-15T21:55:27.270: 160
        // 2018-01-15T21:55:27.270: 140
        // 2018-01-15T21:55:27.270: 40
        // 2018-01-15T21:55:27.271: 110
        // 2018-01-15T21:55:30.270: 120
        // 2018-01-15T21:55:30.270: Bye! ParVector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160)