/* A simple demonstration of race conditions
   and how to use synchronized to avoid them
*/

public class MultiThreadedCounter implements Runnable {


    private int n; /* how many times to increment */
    private boolean goSlow; /* whether to go fast or slow */
    private int howSlow; /* how slow to go--bigger is slower */
    private boolean useSynchronized; /* whether to use synchronized methods or not */
    
    private int count = 0; /* we accumulate a count */

    private double sum = 0.0; /* this is just a time waster--see incrSlow below. */

    /** return the count 
     @return count of how many times incr has been called (supposedly) */

    public int getCount() { return count; }

    /** return the sum
	@return sum of all terms added to sum when "wasting time" */

    public double getSum() { return sum; }

    public void reset() { 
	count = 0;
	sum = 0.0;
    }

    /** Increment count as quickly as Java allows.
     */

    public void incr() { 
	    count++; /* Equivalent to count = count + 1; */ 
    } 

    /** 
	Increment count, but in between, accumulate terms from a sin
	function operating at 1 Hz, 44100 samples per second. This
	function should, over the long term, sum to approximately
	zero.   This is really done just to "waste time" to make the
	window of vulnerability larger for race conditions of 
	incrementing the count.

	@param terms number of terms to accumulate to waste time
    */

    public void incrSlow(int terms) { 
	int oldCount;
	//  = count;
	for (int i=0; i<1000; i++)
	    sum+=Math.sin(i * (2 * Math.PI / 44100.0));
	count = oldCount + 1;
    }

    /** Increment count as quickly as Java allows.
     */

    public synchronized void incrSync() { count++; /* Equivalent to count = count + 1; */ }

    /** 
	Increment count, but in between, accumulate terms from a sin
	function operating at 1 Hz, 44100 samples per second. This
	function should, over the long term, sum to approximately
	zero.   This is really done just to "waste time" to make the
	window of vulnerability larger.

	@param terms number of terms to accumulate to waste time
    */

    public synchronized void incrSlowSync(int terms) { 
	int oldCount = count;
	for (int i=0; i<1000; i++)
	    sum+=Math.sin(i * (2 * Math.PI / 44100.0));
	count = oldCount + 1;
    }
    


    /** Create a thread that will increment count n times.

       @param n How many times to increment
       @param goSlow Whether to use the slow version
       @param howSlow How many terms to accmulate
       @param useSynchronized  Whether to use Synchronized methods
    */


    public MultiThreadedCounter(int n, boolean goSlow, int howSlow, boolean useSyncrhonized) {
	this.n = n;
	this.goSlow = goSlow;
	this.howSlow = howSlow;
	this.useSynchronized = useSynchronized;
    }
    
    /* run the thread and do the work of incrementing n times
     */

    public void run () {
	for (int i=0; i<n; i++) {
	    if (useSynchronized) {
		if (goSlow) {incrSlowSync(howSlow);} else {incrSync();}
	    } else {
		if (goSlow) {incrSlow(howSlow);} else {incr();}
	    }
	} // for
    } // run


    public static void main(String [] args) {

	if (args.length != 4) {
	    System.err.println("Usage: java MultiThreadedCounter n slow s sync\n" +
			       "  n: number of times to increment per thread\n" +
			       "  slow: T or t for true, anything else for false\n" +
			       "  s: number of times to iterate when going slow\n" +
			       "  sync: T or t for true, anything else for false\n" );
	    System.exit(1);
	}

	int n = Integer.parseInt(args[0]);
	boolean goSlow = (args[1].charAt(0)=='T' || args[1].charAt(0)=='t');
	int howSlow = Integer.parseInt(args[2]);
	boolean sync = (args[3].charAt(0)=='T' || args[3].charAt(0)=='t');

	System.out.printf("n=%d goSlow=%s howSlow=%d sync=%s\n", 
			  n, new Boolean(goSlow).toString(), howSlow, new Boolean(sync).toString());
			  

	MultiThreadedCounter mtc = new MultiThreadedCounter(n, goSlow, howSlow, sync);
	Thread t1 = new Thread(mtc);
	Thread t2 = new Thread(mtc);
	System.out.println("In main: About to start threads");
	t1.start();
	t2.start();
	System.out.println("In main: just started threads... waiting for t1 to finish.");

	try {
	    t1.join();
	    System.out.println("In main: t1 finished... waiting for t2 to finish.");
	    t2.join();
	    System.out.println("In main: t2 is finished");
	} catch (InterruptedException ie) {
	    System.out.println(ie);
	    ie.printStackTrace();
	}
	System.out.printf("count=%d sum=%f\n", mtc.getCount(), mtc.getSum());
    }
}