Question

I am trying to understand the keyword synchronized from the following example

Java Main Method –>

public int methodA(){

  Hello h = new Hello();
  h.callSomeSynchronizedMethod();    

  sysout("Main");
  return 0;    

}

In the Hello Class–>

public synchronized void callSomeSynchronizedMethod(){
   Hi h = new Hi();

   h.someMethod();

   sysout("Hello");

}

In the Hi class

public void someMethod(){

    sysout("Hi");
}

So what would be the list of outputs that i will get;

1.) Is it in the order of Hi, Hello and Main ?

2.) What i understand about the synchronized keyword is that it will only execute 1 method and then execute the other, without multi-threading. Is this correct ?

Answer 1

To really understand what synchronized does you need to run the program twice, once synchronized and once not. Also your program should use multiple threads. So here is an example of such a test.

public class Synchro {

    public static void main(String args[]){
        new Synchro();
    }

    public Synchro(){
        final Moo moo = new Moo();
        Thread t = new Thread(new Runnable(){
           public void run(){
               moo.aMethod("Second");
           }
        });
        t.start();//calling the method in a thread

        moo.aMethod("First");//calling the same method from the same object in the main thread
     }

 class Moo{     
    public Moo(){            
    }

    public void aMethod(String name){
        //this loop just prints slowly so you can see the execution
        for(int i = 1; i <= 100; i++){
            System.out.println(String.format("%s : %d", name, i));
            try{
                Thread.sleep(50);
            }catch(InterruptedException e){}
        }
    }
  }

}

Now, if you run the above code, noticing that the method is not synchronized, you will see the printout from the two executions of the method interleaved. That is you will see First 1 then Second 1 then First 2 etc.

Now, add the synchronized keyword to the method making it:

  public synchronized void aMethod(String name){ ....

and run the code again. This time, one execution of the method completes before the other begins.

The synchronized keyword is only necessary when multiple threads are accessing the very same object.