Machine: 4 cores with multithreading.

Default Thread Pool

Default thread pool settings:

akka.actor{
    default-dispatcher {
        type = "Dispatcher"
        executor = "fork-join-executor"

        fork-join-executor {
            parallelism-min = 8
            parallelism-factor = 3.0
            parallelism-max = 64
            task-peeking-mode = "FIFO"
        }

        thread-pool-executor {
            keep-alive-time = 60s
            core-pool-size-min = 8
            core-pool-size-factor = 3.0
            core-pool-size-max = 64
            max-pool-size-min = 8
            max-pool-size-factor  = 3.0
            max-pool-size-max = 64
            task-queue-size = -1
            task-queue-type = "linked"

            allow-core-timeout = on
        }
    }
}

Code

object DefaultSystemThreadPool {

  def main(args: Array[String]): Unit = {
    val system=ActorSystem("ExperimentDefaultThreadPool")
    val e1=system.actorOf(Props[Example1],"example1Actor")
    StdIn.readLine()

    (1 to 100000).foreach{i=>
      e1 ! s"msg$i"
    }

    e1 ! DisplayThreads

    StdIn.readLine()
    system.terminate()

  }

  class Example1 extends Actor{

    var threadsNames=Set[String]()

    override def receive: Receive = {
      case DisplayThreads =>
      println("Example 1 Actor was working in threads")
      threadsNames.foreach(println)

      case msg =>
        threadsNames=threadsNames + Thread.currentThread.getName
        println(s"example1 received $msg")
    }
  }

  object Example1{
    case object DisplayThreads
  }

}

After start without sending any messages

• 1 scheduler
• 3 dispatcher threads
• after one minute of no activity first dispatcher thread was stopped