Use of Synchronized Keyword / Concurrency

Question

I have a program which makes two Writer threads (they add 1 to a shared
counter), A sampler Thread (like a reader thread � it also displays the
data held by the other thread). I have been playing around with the
synchronised keyword � but I am not sure how to interpret the
results..I'll post the code first....
the shared counter------------------------------
package sycTest;
public class Counter
{public int val = 0;}
the sampler / reader class----------------------
package sycTest;
public class Sampler extends Thread
private Counter c;
private MyThread A, B;
public Sampler ( MyThread A, MyThread B, Counter c ) {
this.A = A;
this.B = B;
this.c = c;
public void run()
while(true)
try { sleep( 1000 ); } catch (Exception x) { }
System.out.println
"A count = " + A.getCount() + ", " +
"B count = " + B.getCount() + ": " +
"A + B count = " + (A.getCount() + B.getCount()) + ", " +
"shared counter = " + c.val
the main class to get things started------------------------------------
package sycTest;
import java.util.Random;
public class Main
public static void main( String[] args )
Counter c = new Counter();
MyThread A = new MyThread( c );
MyThread B = new MyThread( c );
A.start(); B.start();
// create and start Sampler thread in one step
new Sampler( A, B, c ).start();
// main thread waits to read a carriage-return.
try {
     System.in.read();
catch( Exception e ) { }
System.exit(0);
/* rand_sleep function is used to generate "random switching" behaviour
assuming n > 0,
rand_sleep( n ) sleeps a random time between 0 and n millisec.
private static Random rand = new Random();
public static void rand_sleep( int maxms ) {
int ms = rand.nextInt() % maxms; // - maxms < ms < maxms
int amt=(ms + maxms + 1)/2;
try { Thread.sleep(amt); } catch(Exception e) { }
the thread / writer class-------------------------------------------
package sycTest;
public class MyThread extends Thread
private Counter sharedCounter;
public MyThread( Counter c ) { this.sharedCounter=c; }
private int count=0;
public int getCount() { return count; }
public void run() {
while(true)
          // simulate non-critical section by sleeping a "large" amount
          Main.rand_sleep(1000);
          synchronized (sharedCounter) {
          criticalSection();
          //Main.rand_sleep(1000);
          ++count;
private void criticalSection() {
int x=sharedCounter.val + 1;
Main.rand_sleep( 100 );
sharedCounter.val=x;
--the question!
The idea is that running the main methods gives something like
A count=13, B count=10: A + B count=23, shared counter=23
(where A and B are writer threads)
If I take out the synchronised keyword in the MyThread class, things get
much worse...the 'personal' totals of A and B do not equal the total
held in the shared counter rather quickly..
          criticalSection();
          //Main.rand_sleep(1000);
          ++count;
eg
A count=13, B count=10: A + B count=23, shared counter=22
However, adding the synchronised keyword (eclipse suggested
�sharedCounter� as the argument � the notes seem to suggest �this�, but
if I do that the synchronised keyword seems much like the example above...
synchronized (sharedCounter) {
          criticalSection();
          ++count;
this makes it much better...I never saw it get the counts 'wrong'
eg
A count=56, B count=72: A + B count=128, shared counter=128
Now comes the confusing bit...when I add some time between the 2 methods
within the sychonized block...
synchronized (sharedCounter) {
          criticalSection();
          Main.rand_sleep(1000);
          ++count;
Then mismatches appear very quickly, the program behaves very similarly
to when it didn't have the synchronised keyword...
Why is this? Is it because the Sampler class is asking what the values
of the shared and personal counters during the �Main.rand sleep(1000)�
call??
The other question I was hoping someone could help me with, is pointing
out what the difference is between �synchronized (sharedCounter)� and
�synchronized (this)� is in this context. Why does the later not do
anything in this example?
Thanks,
Julian

Answer 1

Hello Julian,
you're Sampler thread reads the different counters without any synchronization. He may call A.getCount() and get 5 back, then yield and then ask for c.val which was increased by A in the meantime. Or A increases it's own counter, then yields and lets the Sampler output nonsense.. ;)
To clear up the confusion surrounding Thread.sleep(long): It would be a waste to do nothing while the thread is sleeping, so another thread gets to play. Since the other MyThread is waiting on sharedCounter's monitor and the sleeping thread still owns it¹ the Sampler thread gets the execution time. Now the sampler gets going and you know the rest.
1: http://java.sun.com/docs/books/jls/third_edition/html/memory.html#17.9
EDIT: In future, use code-tags:
class MyClass {
    private int myField;
}will turn into
class MyClass {
    private int myField;
}With kind regards
Ben
Edited by: BenSchulz on Mar 24, 2008 11:45 AM