java 中关于synchronized的通常用法

package j2se.thread.test;

/***
 * synchronized(class)很特别，它会让另一个线程在任何需要获取class做为monitor的地方等待．
 * class与this做为不同的监视器可以同时使用，不存在一个线程获取了class，另一个线程就不能获取该class的一切实例．
        根据下面的代码自行修改,分别验证下面的几种情况：
    synchronized(class)
    synchronized(this)
    －＞线程各自获取monitor，不会有等待．
    synchronized(this)
    synchronized(this)
    －＞如果不同线程监视同一个实例对象，就会等待，如果不同的实例，不会等待．
    synchronized(class)
    synchronized(class)
    －＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
 */


/**
 * @author liwei
    测试synchronized(this)与synchronized(class)
 */
public class TestSynchronied8 {
     private  static byte[] lockStatic = new byte[0]; // 特殊的instance变量
     private byte[] lock = new byte[0]; // 特殊的instance变量
     
     public synchronized void m4t5() {  
         System.out.println(this);
          int i = 50;  
          while( i-- > 0) {  
               System.out.println(Thread.currentThread().getName() + " : " + i);  
               try {  
                    Thread.sleep(100);  
               } catch (InterruptedException ie) {  
               }  
               Thread.yield();
          }  
    } 
     
     public void m4t0() {  
         synchronized(this) {  
             System.out.println(this);
              int i = 50;  
              while( i-- > 0) {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try {  
                        Thread.sleep(100);  
                   } catch (InterruptedException ie) {  
                   }  
                   Thread.yield();
              }  
         }  
    } 
     
     
     public void m4t1() {  
         synchronized(lock) {  
             System.out.println(this);
              int i = 50;  
              while( i-- > 0) {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try {  
                        Thread.sleep(100);  
                   } catch (InterruptedException ie) {  
                   } 
                   Thread.yield();
              }  
         }  
    }  
     /**
     * synchronized(class)
        synchronized(class)
        －＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
     */
    public static synchronized void m4t2() {  
          int i = 50;  
          while( i-- > 0) {  
               System.out.println(Thread.currentThread().getName() + " : " + i);  
               try {  
                    Thread.sleep(100);  
               } catch (InterruptedException ie) {  
               }  
               Thread.yield();
              
          }  
    } 
    
    public static  void m4t3() { 
        synchronized(TestSynchronied8.class){
            int i = 50;  
            while( i-- > 0) {  
                 System.out.println(Thread.currentThread().getName() + " : " + i);  
                 try {  
                      Thread.sleep(100);  
                 } catch (InterruptedException ie) {  
                 }  
                 Thread.yield();
            }  
        }
  } 
    
    public static  void m4t4() { 
        synchronized(lockStatic){
            int i = 50;  
            while( i-- > 0) {  
                 System.out.println(Thread.currentThread().getName() + " : " + i);  
                 try {  
                      Thread.sleep(100);  
                 } catch (InterruptedException ie) {  
                 }
                 Thread.yield();
            }  
        }
  } 

    
    
 /** 
    synchronized(this)
    synchronized(this)
    －＞如果不同线程监视不同的实例，不会等待．
 */
public static void testObjsyn1(){
    final TestSynchronied8 myt2 = new TestSynchronied8();
    final TestSynchronied8 myt1 = new TestSynchronied8();   
    try {
        System.out.println("测试两个不同的对象上，运行同一个synchronized（this）代码块-------------------------------------");
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    Thread t1 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t1"  );   
    Thread t2 = new Thread(  new Runnable() {  public void run() {  myt2.m4t0();  }  }, "t2"  );        
    t1.start();   
    t2.start();  
} 

/** 
synchronized(this)
synchronized(this)
－＞如果不同线程监视同一个实例，会等待．
*/
public static void testObjsyn2(){
    final TestSynchronied8 myt1 = new TestSynchronied8();    
    try {
        System.out.println("测试一个对象上，运行同一个synchronized（this）代码块-------------------------------------");
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    Thread t3 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t3"  );
    Thread t4 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t4"  );
    t3.start();   
    t4.start();   
} 

/** 
synchronized(this)
synchronized(this)
－＞如果不同线程监视同一个实例，会等待．
*/
public static void testObjsyn3(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        System.out.println("测试一个对象上，运行同一个synchronized(obj)代码块-------------------------------------");
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    Thread t5 = new Thread(  new Runnable() {  public void run() {  myt1.m4t1();  }  }, "t5"  );
    Thread t6 = new Thread(  new Runnable() {  public void run() {  myt1.m4t1();  }  }, "t6"  );
    t5.start();   
    t6.start();     
} 

/** 
synchronized(this)
synchronized(this)
－＞如果不同线程监视同一个实例，会等待．
*/
public static void testObjsyn4(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        System.out.println("测试一个对象上，运行同一个synchronized方法-------------------------------------");
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    Thread t7 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t7"  );
    Thread t8 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t8"  );
    t7.start();   
    t8.start(); 
} 

/** 
synchronized(this)
synchronized(this)
－＞如果不同线程监视不同的实例，不会等待．
*/
public static void testObjsyn5(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    final TestSynchronied8 myt2 = new TestSynchronied8();
    try {
        System.out.println("测试两个不同对象上，运行同一个synchronized方法-------------------------------------");
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
     Thread t9 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t9"  );
     Thread t10 = new Thread(  new Runnable() {  public void run() {  myt2.m4t5();  }  }, "t10"  );
     t9.start();   
     t10.start(); 
} 

/** 
synchronized(this)
synchronized方法
－＞如果不同线程监视同一实例，一个是syschronized（this），一个是同步方法，会等待．
*/
public static void testObjsyn6(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
     Thread t9 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t9"  );
     Thread t10 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t10"  );
     t9.start();   
     t10.start(); 
}

/** 
synchronized(lock)
synchronized方法
－＞如果不同线程监视同一实例，一个是syschronized（lock），一个是同步方法，不会等待．
*/
public static void testObjsyn7(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
     Thread t9 = new Thread(  new Runnable() {  public void run() {  myt1.m4t1();  }  }, "t9"  );
     Thread t10 = new Thread(  new Runnable() {  public void run() {  myt1.m4t5();  }  }, "t10"  );
     t9.start();   
     t10.start(); 
}

/** 
synchronized(lock)
synchronized方法
－＞如果不同线程监视同一实例，一个是syschronized（lock），一个是syschronized（this），不会等待．
*/
public static void testObjsyn71(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
     Thread t9 = new Thread(  new Runnable() {  public void run() {  myt1.m4t0();  }  }, "t9"  );
     Thread t10 = new Thread(  new Runnable() {  public void run() {  myt1.m4t1();  }  }, "t10"  );
     t9.start();   
     t10.start(); 
}

/**
     * synchronized(class)
        synchronized(class)
        －＞如果不同线程监视不同的实例对象，会等待．
 */
public static void testObjsyn8(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    final TestSynchronied8 myt2 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
   Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  ); 
   Thread t4 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t4"  ); 
   t2.start(); 
   t4.start(); 
}

/**
 * synchronized(class)
    synchronized(class)
    －＞如果不同线程监视同一的实例对象，会等待．
*/
public static void testObjsyn9(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
    Thread t2 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t2"  ); 
    Thread t4 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t4"  ); 
    t2.start(); 
    t4.start(); 
}

/**
 * synchronized(class)
    synchronized(this)
    －＞线程各自获取monitor，不会有等待．
 */
public static void testObjsyn10(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    final TestSynchronied8 myt2 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
    Thread t7 = new Thread(  new Runnable() {  public void run() { myt2.m4t0();   }  }, "t7"  ); 
    Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t8"  ); 
    t7.start(); 
    t8.start(); 
}

/**
 * synchronized(class)
    synchronized(this)
    －＞线程各自获取monitor，不会有等待．
 */
public static void testObjsyn11(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
    Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t0();   }  }, "t7"  ); 
    Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t8"  ); 
    t7.start(); 
    t8.start(); 
}

/**
 * synchronized(class)
    synchronized(lock)
    －＞线程各自获取monitor，不会有等待．
 */
public static void testObjsyn12(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
    Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t1();   }  }, "t7"  ); 
    Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t8"  ); 
    t7.start(); 
    t8.start(); 
}


/**
 * synchronized(class)
    synchronized(lockStatic)
    －＞线程各自获取monitor，不会有等待．
 */
public static void testObjsyn13(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
    Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t4();   }  }, "t7"  ); 
    Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t8"  ); 
    t7.start(); 
    t8.start(); 
}

/**
 * synchronized方法
    synchronized(lockStatic)
    －＞线程各自获取monitor，不会有等待．
 */
public static void testObjsyn14(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
    Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t4();   }  }, "t7"  ); 
    Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t8"  ); 
    t7.start(); 
    t8.start(); 
}

/**
 * synchronized方法
    synchronized(lockStatic)
    －＞线程各自获取monitor，不会有等待．
 */
public static void testObjsyn15(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
    Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t3();   }  }, "t7"  ); 
    Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t2();   }  }, "t8"  ); 
    t7.start(); 
    t8.start(); 
}

/**
 * synchronized方法
    synchronized(lockStatic)
    －＞线程各自获取monitor，不会有等待．
 */
public static void testObjsyn16(){
    final TestSynchronied8 myt1 = new TestSynchronied8();
    try {
        Thread.sleep(500);
     } catch (InterruptedException e) {
        e.printStackTrace();
     } 
    Thread t7 = new Thread(  new Runnable() {  public void run() { myt1.m4t1();   }  }, "t7"  ); 
    Thread t8 = new Thread(  new Runnable() {  public void run() { myt1.m4t4();   }  }, "t8"  ); 
    t7.start(); 
    t8.start(); 
}



    
    /**
     *  synchronized(class)和static synchronized 方法所获取的锁是一样的
     *  synchronized(class)方法和静态的方法中的 synchronized(lockStatic)代码块获取的锁是不一样的
     *  非静态的方法中的synchronized(this)代码块和非静态的 synchronized 方法所获取的锁是一样的
     * (静态和非静态) synchronized(this)和(静态和非静态)的 synchronized(lock)代码块获取的锁是不一样的
     * 
     * 总的来说synchronized(class)和static synchronized 方法获取的是类锁
     * 非静态的方法中的synchronized(this)代码块和非静态的 synchronized 方法所获取的锁是类的实例的对象锁  
     *  synchronized(lockStatic)获取的是静态属性的锁
     *  synchronized(lock) 获取的是非静态属性的锁
     *  如果获取的锁是一样的，代码就会同步 ；锁不一样就不会同步 
     */
    public static void main(String[] args) {  
        //对于非静态的方法，同步方法和 synchronized(this) 获取的是实例对象锁
        //对于非静态的方法，同步方法和 synchronized(lock) 获取的锁的lock
        
//        testObjsyn1();//如果不同线程监视不同的实例，不会等待． synchronized(this)
//        testObjsyn2();//如果不同线程监视同一个实例，会等待． synchronized(this)  
//        testObjsyn3();//如果不同线程监视同一个实例，会等待． synchronized(lock)
//        testObjsyn4();//如果不同线程监视同一个实例，会等待． synchronized 方法
//        testObjsyn5();//如果不同线程监视不同的实例，不会等待． synchronized 方法
//        testObjsyn6();//如果不同线程监视同一实例，一个是syschronized（this），一个是同步方法，会等待
//        testObjsyn7(); //如果不同线程监视同一实例，一个是syschronized（lock），一个是同步方法，不会等待，锁定的对象不一样的
//        testObjsyn71(); //如果不同线程监视同一实例，一个是syschronized（lock），一个是syschronized（this），不会等待，锁定的对象不一样的
        
        
        /**
           * synchronized(class)
              synchronized(class)
              －＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
           */
//        testObjsyn8();//如果不同线程监视不同的实例对象，会等待．synchronized(class)
//        testObjsyn9();//如果不同线程监视同一的实例对象，会等待．synchronized(class)
//        testObjsyn10();//如果不同线程监视不同的实例对象，不会等待．synchronized(class)，synchronized(this)       
//        testObjsyn11();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(this)   
//        testObjsyn12();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(lock)        
//        testObjsyn13();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(lockStatic)  
//        testObjsyn14();//如果不同线程监视同一的实例对象，不会等待．synchronized()方法，synchronized(lockStatic)        
//        testObjsyn15();//如果不同线程监视同一的实例对象，会等待．synchronized()方法，synchronized(class)        
//        testObjsyn16();//如果不同线程监视同一的实例对象，不会等待．synchronized(lock)方法，synchronized(lockStatic)        

    } 
}