Accepted answer

For scala 2.10

You can use scala.concurrent.future and then register a callback on completion. The callback will update the GUI on the EDT thread.

Lets do it!

//in your swing gui event listener (e.g. button clicked, combo selected, ...)
import scala.concurrent.future
//needed to execute futures on a default implicit context
import scala.concurrent.ExecutionContext.Implicits._ 

val backgroundOperation: Future[Result] = future {
    //... do that thing, on another thread

//this goes on without blocking
backgroundOperation onSuccess {
    case result => Swing.onEDT {
        //do your GUI update here

This is the most simple case:

  1. we're updating only when done, with no progress
  2. we're only handling the successful case

To deal with (1) you could combine different futures, using the map/flatMap methods on the Future instance. As those gets called, you can update the progress in the UI (always making sure you do it in a Swing.onEDT block

//example progress update
val backgroundCombination = backgroundOperation map { partial: Result =>
    //process the partial result and obtain
} //here you can map again and again

def progress(step: Int) {
    Swing.onEDT {
        //do your GUI progress update here

To deal with (2) you can register a callback onFailure or handle both cases with the onComplete.

For relevant examples: scaladocs and the relevant SIP (though the SIP examples seems outdated, they should give you a good idea)


If you need something simple you can run the long task in a new Thread and just make sure to update it in the EDT:

  def swing(task: => Unit) = SwingUtilities.invokeLater(new Runnable {
     def run() { task }
  def thread(task: => Unit) = new Thread(new Runnable {
     def run() {task}

    val stuff = longRunningTask()


You can define your own ExecutionContext which will execute anything on the Swing Event Dispatch Thread using SwingUtilities.invokeLater and then use this context to schedule a code which needs to be executed by Swing, still retaining the ability to chain Futures the Scala way, including passing results between them.

  import javax.swing.SwingUtilities
  import scala.concurrent.ExecutionContext

  object OnSwing extends ExecutionContext {
    def execute(runnable: Runnable) = {
    def reportFailure(cause: Throwable) = {
      case ButtonClicked(_)  =>
        Future {
        }.foreach { result =>
          txtStatus.text = result


If you want to use Actors, following may work for you.

There are two actors:

  • WorkerActor which does data processing (here, there is simple loop with Thread.sleep). This actor sends messages about progress of work to another actor:
  • GUIUpdateActor - receives updates about progress and updates UI by calling handleGuiProgressEvent method

UI update method handleGuiProgressEvent receives update event. Important point is that this method is called by Actor using one of Akka threads and uses Swing.onEDT to do Swing work in Swing event dispatching thread.

You may add following to various places to see what is current thread.

println("Current thread:" + Thread.currentThread())

Code is runnable Swing/Akka application.

import{Props, ActorRef, Actor, ActorSystem}
import swing._
import event.ButtonClicked

trait GUIProgressEventHandler {
  def handleGuiProgressEvent(event: GuiEvent)

abstract class GuiEvent

case class GuiProgressEvent(val percentage: Int) extends GuiEvent
object ProcessingFinished extends GuiEvent

object SwingAkkaGUI extends SimpleSwingApplication with GUIProgressEventHandler {

  lazy val processItButton = new Button {text = "Process it"}
  lazy val progressBar = new ProgressBar() {min = 0; max = 100}

  def top = new MainFrame {
    title = "Swing GUI with Akka actors"

    contents = new BoxPanel(Orientation.Horizontal) {
      contents += processItButton
      contents += progressBar
      contents += new CheckBox(text = "another GUI element")

    val workerActor = createActorSystemWithWorkerActor()


    reactions += {
      case ButtonClicked(b) => {
        processItButton.enabled = false
        processItButton.text = "Processing"
        workerActor ! "Start"



  def handleGuiProgressEvent(event: GuiEvent) {
    event match {
      case progress: GuiProgressEvent  => Swing.onEDT{
        progressBar.value = progress.percentage
      case ProcessingFinished => Swing.onEDT{
        processItButton.text = "Process it"
        processItButton.enabled = true


  def createActorSystemWithWorkerActor():ActorRef = {
    def system = ActorSystem("ActorSystem")

    val guiUpdateActor = system.actorOf(
      Props[GUIUpdateActor].withCreator(new GUIUpdateActor(this)), name = "guiUpdateActor")

    val workerActor = system.actorOf(
      Props[WorkerActor].withCreator(new WorkerActor(guiUpdateActor)), name = "workerActor")


  class GUIUpdateActor(val gui:GUIProgressEventHandler) extends Actor {
    def receive = {
      case event: GuiEvent => gui.handleGuiProgressEvent(event)

  class WorkerActor(val guiUpdateActor: ActorRef) extends Actor {
    def receive = {
      case "Start" => {
        for (percentDone <- 0 to 100) {
            guiUpdateActor ! GuiProgressEvent(percentDone)
      guiUpdateActor ! ProcessingFinished


Related Query

More Query from same tag