测试 Java 方法同步的好方法是什么？

Question

我有几个实现某些接口的类。该接口有一个契约，即某些方法应该同步，有些方法不应该同步，我想通过所有实现的单元测试来验证该契约。这些方法应该使用synchronized关键字或锁定在this上——与synchronizedCollection()包装器非常相似。这意味着我应该能够从外部观察它。

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

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

Answer 1

如果您只想检查一个方法是否具有 synchronized 修饰符，除了明显的（查看源代码/Javadoc）之外，您还可以使用反射。

Modifier.isSynchronized(method.getModifiers())

测试方法是否保证所有并发场景中正确同步的更普遍的问题可能是一个无法判定的问题。

Answer 2

这些都是可怕的想法，但你可以这样做...

1

    // Substitute this LOCK with your monitor (could be you object you are
    // testing etc.)
    final Object LOCK = new Object();
    Thread locker = new Thread() {
        @Override
        public void run() {
            synchronized (LOCK) {
                try {
                    Thread.sleep(Long.MAX_VALUE);
                } catch (InterruptedException e) {
                    System.out.println("Interrupted.");
                    return;
                }
            }
        }
    };

    locker.start();

    Thread attempt = new Thread() {
        @Override
        public void run() {
            // Do your test.
        }
    };

    attempt.start();
    try {
        long longEnough = 3000 * 1000;// It's in nano seconds

        long before = System.nanoTime();
        attempt.join(longEnough);
        long after = System.nanoTime();

        if (after - before < longEnough) {
            throw new AssertionError("FAIL");
        } else {
            System.out.println("PASS");
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return;
    }
    locker.interrupt();

2

如果你知道在任何实现中总是调用参数上的方法，你可以传递一个伪装成参数并调用 HoldLock() 的模拟对象。

就像这样：

class Mock implements Argument {
    private final Object LOCK;
    private final Argument real;
    public Mock(Object obj, Argument real){
       this.LOCK=obj;
       this.real = real;
    }

    @Overrides
    public void something(){
        System.out.println("held:"+Thread.holdsLock(LOCK));
        this.real.something();
    }

然后等待类在 Argument 上调用 Something() 。

Answer 3

非常感谢 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
        }
    }
}

Answer 4

使用反射，获取方法的 Method 对象，并对其调用 toString() 。 “synchronized”关键字应该出现在 toString() 的输出中。