Use of 'static' keyword in synchronized methods. Does it ease concurrency?

Question

Friends,
I have a query regarding the use of 'synchronized' keyword in a programme. This is mainly to check if there's any difference in the use of 'static' keyword for synchronized methods. By default we cannot call two synchronized methods from a programme at the same time. For example, in 'Program1', I am calling two methods, 'display()' and 'update()' both of them are synchronized and the flow is first, 'display()' is called and only when display method exits, it calls the 'update()' method.
But, things seem different, when I added 'static' keyword for 'update()' method as can be seen from 'Program2'. Here, instead of waiting for 'display()' method to finish, 'update()' method is called during the execution of 'display()' method. You can check the output to see the difference.
Does it mean, 'static' keyword has anything to do with synchronizaton?
Appreciate your valuable comments.
1. Program1
public class SynchTest {
     public synchronized void display() {
          try {
               System.out.println("start display:");
               Thread.sleep(7000);
               System.out.println("end display:");
          } catch (InterruptedException e) {
               e.printStackTrace();
     public synchronized void update() {
          try {
               System.out.println("start update:");
               Thread.sleep(2000);
               System.out.println("end update:");
          } catch (InterruptedException e) {
               e.printStackTrace();
     public static void main(String[] args) {
          System.out.println("Synchronized methods test:");
          final SynchTest synchtest = new SynchTest();
          new Thread(new Runnable() {
               public void run() {
                    synchtest.display();
          }).start();
          new Thread(new Runnable() {
               public void run() {
                    synchtest.update();
          }).start();
Output:
Synchronized methods test:
start display:
end display:
start update:
end update:
2. Program2
package camel.java.thread;
public class SynchTest {
     public synchronized void display() {
          try {
               System.out.println("start display:");
               Thread.sleep(7000);
               System.out.println("end display:");
          } catch (InterruptedException e) {
               e.printStackTrace();
     public static synchronized void update() {
          try {
               System.out.println("start update:");
               Thread.sleep(2000);
               System.out.println("end update:");
          } catch (InterruptedException e) {
               e.printStackTrace();
     public static void main(String[] args) {
          System.out.println("Synchronized methods test:");
          final SynchTest synchtest = new SynchTest();
          new Thread(new Runnable() {
               public void run() {
                    synchtest.display();
          }).start();
          new Thread(new Runnable() {
               public void run() {
                    synchtest.update();
          }).start();
Output:
Synchronized methods test:
start display:
start update:end update:
end display:

Answer 1

the synchronized method obtain the lock from the current instance while static synchronized method obtain the lock from the class
Below is some code for u to have better understanding
package facado.collab;
public class TestSync {
     public synchronized void add() {
          System.out.println("TestSync.add()");
          try {
               Thread.sleep(2000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          System.out.println("TestSync.add() - end");          
     public synchronized void update() {
          System.out.println("TestSync.update()");
          try {
               Thread.sleep(2000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          System.out.println("TestSync.update() - end");          
     public static synchronized void staticAdd() {
          System.out.println("TestSync.staticAdd()");
          try {
               Thread.sleep(2000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          System.out.println("TestSync.staticAdd() - end");
     public static synchronized void staticUpdate() {
          System.out.println("TestSync.staticUpdate()");
          try {
               Thread.sleep(2000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          System.out.println("TestSync.staticUpdate() - end");
     public static void main(String[] args) {
          final TestSync sync1 = new TestSync();
          final TestSync sync2 = new TestSync();
          new Thread(new Runnable(){
               public void run() {
                    sync1.add();
          }).start();
          new Thread(new Runnable(){
               public void run() {
                    sync2.update();
          }).start();
          try {
               Thread.sleep(3000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          new Thread(new Runnable(){
               public void run() {
                    sync1.staticAdd();
          }).start();
          new Thread(new Runnable(){
               public void run() {
                    sync2.staticUpdate();
          }).start();
}