有什么好的方法可以测试Java方法是否已同步？

Question

我有几个实现某些接口的类。该接口有一个约定，某些方法应该同步，有些方法应该不同步，我想通过单元测试对所有实现进行验证。这些方法应使用synced关键字或将其锁定this-与SynchronizedCollection（）包装器非常相似。这意味着我应该能够从外部观察它。

如果我有一个调用iterator（）的线程来继续Collections.synchronizedCollection（）的示例，我仍然应该能够使用另一个线程进入add（）之类的方法，因为iterator（）不应进行任何锁定。另一方面，我应该能够在集合上进行外部同步，并看到另一个线程在add（）上阻塞。

有没有很好的方法来测试方法是否在JUnit测试中同步？ 我想避免长时间睡眠的陈述。

Answer 1

非常感谢Zwei steinen编写了我使用的方法。我处理过的示例代码中存在一些问题，因此我认为值得在这里发表我的发现。

• 对join（）的调用期望以毫秒为单位，而不是纳秒。
• 这两个线程必须协调，否则尝试线程可以在更衣室线程获取锁之前开始和结束所有线程。
• 直到我们记录了开始时间之后，才应该开始尝试线程。否则，该线程将获得足够的领先优势，以至于记录的时间可能比超时时间稍短，从而导致虚假故障。

这是作为Scala特性的同步测试代码：

trait SynchronizedTestTrait
{
    val classUnderTest: AnyRef

    class Gate
    {
        val latch = new java.util.concurrent.CountDownLatch(1)

        def open()
        {
            this.latch.countDown
        }

        def await()
        {
            this.latch.await
        }
    }

    def nanoTime(code: => Unit) =
    {
        val before = System.nanoTime
        code
        val after = System.nanoTime
        after - before
    }

    def assertSynchronized(code: => Unit)
    {
        this.assertThreadSafety(threadSafe = true, millisTimeout = 10L)(code)
    }

    def assertNotSynchronized(code: => Unit)
    {
        this.assertThreadSafety(threadSafe = false, millisTimeout = 60L * 1000L)(code)
    }

    def assertThreadSafety(threadSafe: Boolean, millisTimeout: Long)(code: => Unit)
    {
        def spawn(code: => Unit) =
        {
            val result = new Thread
            {
                override def run = code
            }
            result.start()
            result
        }

        val gate = new Gate

        val lockHolderThread = spawn
        {
            this.classUnderTest.synchronized
            {
                // Don't let the other thread start until we've got the lock
                gate.open()

                // Hold the lock until interruption
                try
                {
                    Thread.sleep(java.lang.Long.MAX_VALUE)
                }
                catch
                {
                    case ignore: InterruptedException => return;
                }
            }
        }

        val measuredNanoTime = nanoTime
        {
            // Don't start until the other thread is synchronized on classUnderTest
            gate.await()
            spawn(code).join(millisTimeout, 0)
        }

        val nanoTimeout = millisTimeout * 1000L * 1000L

        Assert.assertEquals(
            "Measured " + measuredNanoTime + " ns but timeout was " + nanoTimeout + " ns.",
            threadSafe,
            measuredNanoTime > nanoTimeout)

        lockHolderThread.interrupt
        lockHolderThread.join
    }
}

现在，我们要测试一个简单的类：

class MySynchronized
{
    def synch = this.synchronized{}
    def unsynch = {}
}

测试看起来是这样的：

class MySynchronizedTest extends SynchronizedTestTrait
{
    val classUnderTest = new MySynchronized


    @Test
    def synch_is_synchronized
    {
        this.assertSynchronized
        {
            this.classUnderTest.synch
        }
    }

    @Test
    def unsynch_not_synchronized
    {
        this.assertNotSynchronized
        {
            this.classUnderTest.unsynch
        }
    }
}