synchronized

[K Anshul]

i have problems understnding synchronized access to methods.
I wrote the following code to print values one after the another(that is A followed by B followed by C). But i am not getting it right.

  public class Test extends Thread {
 
      StringBuffer arg;
  public Test(StringBuffer arg) {
     this.arg = arg;
  }
  public static void main(String []args) {
             StringBuffer a = new StringBuffer("A");
             StringBuffer b = new StringBuffer("B");
             StringBuffer c = new StringBuffer("C");
 
             Test t = new Test(a);
             Test t1 = new Test(b);
             Test t2 = new Test(c);
     t.start();
     t1.start();
     t2.start();
  }
 
  public void run() {
      synchronized(arg) {
  for(int i=0; i<100; i++) {
         System.out.println(arg);       
  }
}
  }
   
 }
 

[Barry Gaunt]

You must synchronize on ONE unique object. In your example you are synchronizing on THREE different objects. If you can create an object which is shared by the three thread objects and synchronize on that you will get the result you want. You could pass the shared object into the Test constructor as an additional parameter. You could also synchronize on the Test class object itself.
[ June 23, 2004: Message edited by: Barry Gaunt ]

[K Anshul]

Thanks for replying.
What modifications do i need to make in my code to make it work?

[Barry Gaunt]

I've updated my last post to give you a clue . Let us know if you still have a problem.

[K Anshul]

Thanks Barry
I did the following but don't know why its working.
I synchronized only t2 but even other 2 display results as if they were also synchronizde.

 public class Test extends Thread { 
 StringBuffer arg; 
static Test t, t1, t2;
 public Test(StringBuffer arg) { 
 this.arg = arg;
 }
 public static void main(String []args) {  
 StringBuffer a = new StringBuffer("A"); 
 StringBuffer b = new StringBuffer("B"); 
 StringBuffer c = new StringBuffer("C"); 
 t = new Test(a);   
 t1 = new Test(b);   
 t2 = new Test(c); 
 t.start();   
 t1.start(); 
 t2.start();  
 }
 public void run() {   
 synchronized(t2) {
 for(int i=0; i<100; i++) {  
 System.out.print(arg); 
     }
           System.out.println(); 
        }
    }
         } 

[Chris Hani]

I also want to know what happens in the replied code. It seems like when t finished, it is guaranteed t1 is selected before t2. As far as I know the the thread scheduling is totally upto platform.

I am looking forward to another explaination.

sung.
[ June 24, 2004: Message edited by: Sung Kum Her ]

[K Anshul]

Originally posted by Sung Kum Her:
I also want to know what happens in the replied code. It seems like when t finished, it is guaranteed t1 is selected before t2. As far as I know the the thread scheduling is totally upto platform.

I am looking forward to another explaination.

sung.

[ June 24, 2004: Message edited by: Sung Kum Her ]

The same reason i couldn't understand why its working.

[Chris Hani]

By the way, this is my solution. Welcome to be criticised

  
 
public class Test extends Thread {
static Semaphore nSemaphore = new Semaphore() ;
StringBuffer arg;
int nMyLocation = 0;
  
public Test(StringBuffer arg, int n) {
this.arg = arg;
this.nMyLocation = n ;
}
public static void main(String []args) {
StringBuffer a = new StringBuffer("A"  );             
StringBuffer b = new StringBuffer("B" );             
StringBuffer c = new StringBuffer("C" );              

Test t = new Test(a, 0);             
Test t1 = new Test(b, 1);             
Test t2 = new Test(c, 2);     

t.start();     
t1.start();     
t2.start();  
}   
public synchronized void run() {      
if ( nSemaphore.isMyTurn(nMyLocation) ){
for(int i=0; i<50; i++) {         
System.out.print(arg);
  }// end of for
System.out.println(); 
nSemaphore.increaseSemaphore() ;
}
}// end of run 
 
}// end of class
class Semaphore{
int nSema = 0 ;

public synchronized boolean  isMyTurn( int nMyLocation ){
while ( nSema != nMyLocation ){
try{
wait() ;
}catch ( InterruptedException e){
}
}// end of while
return true ;
}

public synchronized void  increaseSemaphore(){
nSema++ ;
notifyAll() ;
}
}

[Barry Gaunt]

Here's my version of the original problem. Read the comments.
Sorry but I don't have time to write more at the moment, got to do some work.

 
public class Test extends Thread {
  // This is the unique shared object to be synchronised on.
  // The object is created when the class is loaded.
  static Object objectToSyncOn = new Object();
  
  StringBuffer arg; // unique to this object
 

  /**
   *Constructor for the Test object
   *
   * @param  arg  StringBuffer containing Buffer to be printed.
   */
  public Test( StringBuffer arg ) {
    this.arg = arg;
  }
 

  /**
   *  The main program for the Test class
   *
   * @param  args  Dummy (not used)
   */
  public static void main( String[] args ) {
    StringBuffer a = new StringBuffer( "A" );
    StringBuffer b = new StringBuffer( "B" );
    StringBuffer c = new StringBuffer( "C" );
        
    Thread t = new Test( a );
    Thread t1 = new Test( b );
    Thread t2 = new Test( c );
 
    // Although we start the threads in this order the running
    // order is up to the JVM. Do not try in any way to predict
    // the order: using a different JVM may produce different results,
    // as may adding a few more CPUs to the computer
    t.start();
    t1.start();
    t2.start();
    
    // The main thread exits here but the threads t, t1, t2 will run
    // on because they are not daemon threads
  }
 

  /**
   *  Main processing method for the Test (a Thread) object
   */
  public void run() {
    // Once this method has synchronized on the shared object
    // it will print its string 100 times without letting
    // any other thread interrupting the flow of the prints
    synchronized ( objectToSyncOn ) {
      for ( int i = 0; i < 100; i++ ) {
        System.out.print( arg.toString() );
      }
      System.out.println();
    }
  }
}

On my computer it outputs:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

[Robert Miller]

Any statements enclosed by

        synchronized (a) {
        }

will be executed only after the thread gets a lock on object a. Such a block has no effect on a block such as

        synchronized (b) {
        }

unless it happens that a==b. This is because each Java object has its own lock.

Therefore, in order for two blocks of code to be synchronized with each other, they must synchronize on the same object. That's why having every thread synchronize on the same thread object works.

Robert