How to write unit tests that tests concurrency invariants

Question

There are other questions about this issue, but I'm trying to figure how to approach unit testing something like this:

 public class Semaphore extends Lock {
        private AtomicInteger semaphore = new AtomicInteger(0);
        public synchronized boolean available() {
                return semaphore.intValue() == 0;
        }
        public synchronized void acquire() {
            semaphore.incrementAndGet();

        }
        public synchronized void release() {
            semaphore.decrementAndGet();
        }
    }

This is my homespun locking mechanism (just for learning purposes). How would I test the thread safety of this? I know that there are no guarantees when it comes to unit testing concurrent code, but how would I even go about writing a unit test that ATTEMPTS to test the obvious invariants inherent in this locking mechanism?

Answer 1

I guess I'll answer my own question since I did some research. There's a great framework called MultithreadedTC. It allows you to set up tests like so:

public class SafeSemaphoreTest extends MultithreadedTestCase {

    private SafeSemaphore semaphore;
    AtomicInteger ai = new AtomicInteger(0);

    @Override
    public void initialize() {
        semaphore = new SafeSemaphore();
    }


    public void thread1() throws InterruptedException {

        assertTick(0);

        semaphore.acquire();
        waitForTick(2);
        assertTick(2);

        semaphore.acquire();
        assertEquals(semaphore.getValue(), 2);
        assertEquals(semaphore.getValue()==3, false);
        semaphore.release();
        semaphore.release();

    }

    public void thread2() throws InterruptedException {
        waitForTick(1);
        assertTick(1);
        assertEquals(semaphore.available(), false);
        waitForTick(3);
        assertTick(3);
        assertEquals(semaphore.available(), true);

    }

}

where the waitForTick(int) calls make the current Thread block until the tick is reached. There was even some development to make this a bit more modern for better JUnit integration: http://janvanbesien.blogspot.com/2009/06/modernizing-multithreadedtc-junit-4.html