why does this scala by-name parameter behave weirdly

Question

OK the question might not say much, but here's the deal: I'm learning scala and decided to make an utility class "FuncThread" with a method which receives a by-name parameter function (I guess its called that because it's a function but without a parameter list) and then starts a thread with a runable which in turn executes the passed function, I wrote such a class as follows:

class FuncThread
{
   def runInThread( func: => Unit)
   {
     val thread = new Thread(new Runnable()
     {
        def run()
        {
          func
        }
     }

     thread.start()
   }
}

Then I wrote a junit test as follows:

@Test
def weirdBehaivorTest()
{
  var executed = false
  val util = new FuncThread()
  util.runInThread
  {
    executed = true
  }

  //the next line makes the test pass....
  //val nonSense : () => Unit  = () => { Console println "???" }

  assertTrue(executed)
}

If I uncomment the second commented line, the test passes but if it remains commented the test fails, is this the correct behaviour? how and when do by-name parameter functions get executed?

I know Scala has the actors library but I wanted to try this since I've always wanted to do this in Java

Answer 1

Is this just a race condition? runInThread starts the thread but your assertion tests 'executed' before the other thread sets it to true. Adding your extra line means more code (and so time) is executed before the test, making it more likely that 'executed' has been set to true

Answer 2

This is not an answer, it's a comment, but I can't add a comment yet...

-You are missing a closed parenthesis just before thread.start()

-And welcome to the "I've always wanted to do this in Java" club

Answer 3

It's also worth noting that (as of Scala 2.8), the construct you were trying to write is available in the standard library

import scala.actors.Futures._

future{
    executed = true
}

This construct is actually more powerful than what you're describing, the thread calculation can return a value, and which can be waited for.

import scala.actors.Futures._

//forks off expensive calculation
val expensiveToCalculateNumber:Future[Int] = future{
    bigExpensiveCalculation()  
}

// do a lot of other stuff

//print out the result of the expensive calculation if it's ready, otherwise wait until it is
println( expensiveToCalculateNumber());