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)        

    }
}