Synchronized Static & Non Satatic methods

Question

Is synchronized static method acquire lock ? I have wriietn a code in which i synchronized a static & non static(instance) method. but statc method call is not acquiring a lock.
If its not posible then there is a chance of corruption of static data.
plz inform me
my code is given below
public class TestThread{
     private static int i=0;
     public synchronized static void m1(){
          System.out.println("1 Static M1 \t");     
          i++;     
          try{Thread.sleep(10000);}
          catch(Exception e){e.printStackTrace();}
          System.out.println("2 Static M1 \t");
     public synchronized void m2(){
          System.out.println("1 Static M2 \t");
          i++;
          try{Thread.sleep(10000);}
          catch(Exception e){e.printStackTrace();}
          System.out.println("2 Static M2 \t");
     public static void main(String[] args){
          new Thread(){
               public void run(){     
                    TestThread.m1();               
          }.start();
     try{Thread.sleep(100);}
     catch(Exception e){e.printStackTrace();}
          new Thread(){
               public void run(){     
                    new TestThread().m2();               
          }.start();

Answer 1

Your example has two methods, both of which modify a static integer of the same class.
Both of your methods are synchronized - but - one is static and one isn't. A synchronized static method aquires the 'lock' of the class, where as a non-static method aquires the 'lock' of the object.
For this reason, your two method calls are locking on different objects and so they may be invoked by different threads executing at the 'same time'.
Just to clarify, you can see this:
class Test {
  private static int i = 0;
  public static synchronized modifyStatic() {
    ++i;
  public synchronized modify() {
    ++i;
}As being this:
class Test {
  private static int i = 0;
  public static modifyStatic() {
    synchronized(Test.class) {
        ++i; 
  public modify() {
    synchronized(this) {
      ++i;
}So, as you can see from above, the two locks aquired are not the same.
Dave