com.atlassian.utt.concurrency

Class SyncTest

java.lang.Object

com.atlassian.utt.concurrency.SyncTest

public class SyncTest
extends Object

Constructor Summary

Constructors

Constructor and Description
SyncTest()

Method Summary

Modifier and Type	Method and Description
void	testSync2_roundRobin() Multiple 2-party syncs are used to coordinate control among three threads.
void	testSync3Parties() A single 3-party sync is used to coordinate control among three threads.
void	testSyncRaces() Multiple threads loop around the same sync with the party count equal to the number of threads.
void	testSyncTimeout()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SyncTest

public SyncTest()

Method Detail

testSync2_roundRobin

public void testSync2_roundRobin()
                          throws Exception

Multiple 2-party syncs are used to coordinate control among three threads. Each sync is named syncXY, where X is the thread that is expected to have control and Y is the thread that is receiving control. For example, sync12 is only used by threads 1 and 2, never by thread 3. It is called by thread 1 just after adding a number (meaning when it had control) and by thread 2 just before adding a number (meaning it is waiting for control). The numbers are arranged such that the correct control flow results in counting from 1 to 10.

Throws:

Exception

testSync3Parties

public void testSync3Parties()

A single 3-party sync is used to coordinate control among three threads. There are three syncs between calls to add a number. The first transfers control to the next thread to add a number (such as from thread 1 to thread 2). The second is required because all three threads must hit the sync for that thread to pass control on (from thread 2 to thread 3). The third is to accept control back (from thread 3 to thread 1). The numbers are arranged such that the correct control flow results in counting from 1 to 7.

testSyncRaces

public void testSyncRaces()

Multiple threads loop around the same sync with the party count equal to the number of threads. Each thread writes its loop counter to a thread-safe structure, with the expected result being that every thread does so in lock step, and all loop counters are contiguous in the result. That is, loop 1 happens for every thread, then loop 2 happens for every thread, and so on.

testSyncTimeout

public void testSyncTimeout()