如何从多个线程同时调用方法？

Question

I have an application that should (in some cases) guard against multiple threads. In order to have a test for that I need to call a method from multiple threads simultaneously at the same time.

class MyObject {

  val myMethodCalled = new AtomicBoolean()   

  def myMethod() = {

    if (myMethodCalled.getAndSet(true))
      throw new IllegalStateException("Do not call myMethod twice")
  }
}

I want to trigger the exception in the above method from a test case.

Is this possible in the JVM ? If so, how to do it?

Edit

I was wondering if there was any way (using some trick or a class I don't know) to call a method at the exact same time within the virtual machine. I guess that's not possible.

Answer 1

You should slow down the processing of your method by sleeping in the middle of it ( Thread.sleep ) or doing time-consuming busywork, and then have two or more other threads call that method as fast as they can.

You also can abstract out your run-only-once functionality so you can test it in isolation. Eg

def onlyOnce[A](f: => A) = {
  if (myMethodCalled.getAndSet(true)) throw new Exception("Twice!")
  f
}

and then when you need to test whether this in fact works, you pass in a slowly-executing f to make testing easy. Otherwise, in your once-only methods you

def doSomething = onlyOnce {
}

which if you have tested onlyOnce properly will not go wrong (assuming things are properly encapsulated so that the body of f doesn't mess up the value of myMethodCalled ).

Finally, your best bet otherwise is to use a machine with at least three real execution threads and have two of them do busywaiting where one flips a volatile var that the other is reading and then both run the method. This is not inherently reliable, but if you have small busy-wait offsets between the two and cover the relevant space a bunch of times, you can at least make a statistical argument that you're okay at least almost all the time.

Answer 2

Simply change your def to a lazy val and you can be garaunteed it will only run once:

object MyObject {

// static field
val myMethodCalled = new AtomicBoolean()   

// static method
lazy val myMethod = {
  if (myMethodCalled.getAndSet(true))
    throw new IllegalStateException("Do not call myMethod twice")
  }
}

Answer 3

I am a little puzzled by the need for the AtomicBoolean. Because you're using it, you should do the decent thing and write a test. That's good. However, testing threaded code is jolly hard on the JVM (and not particularly easy in other languages even without the JVM's handicaps).

Fortunately, there may be a simpler solution in your case. It seems you're perhaps trying to detect when a particular method has been accidentally used concurrently. Could you instead prevent it from being so used? For example:

class MyObject {
  def myMethod() {
    synchronized {
      .. stuff in here is serialized by the Hoare Monitor
    }
  }
}

An effective alternative strategy is to isolate sequential behaviour within a purpose-designed module. This is the general principle behind the actor pattern, and also the more general CSP algebra (used in Occam, Go, Limbo and available on the JVM via the JCSP API). Testing sequential code is generally much easier, so these patterns help you partition the task into manageable chunks.

There are at four concurrency failures that cannot be eliminated purely by testing alone, about which I wrote an article a while ago .