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) } }