Java synchronized同步方法和同步块总结

今天做了一些实验,把Java synchronized同步方法和同步块总结一下,欢迎拍砖! 

Java synchronized同步方法和同步块总结: 

1、非静态 同步方法: 
synchronized method() {...} 锁对象的所有同步方法 
一个进程进入某对象同步方法后,其它线程不能同时访问这个对象中任何一个同步方法 


Java代码  收藏代码
  1. /****************************************************************************************  
  2.  Copyright © 2014 Your Company/Org. All rights reserved.<br>  
  3.  Reproduction or transmission in whole or in part, in any form or<br> 
  4.  by any means, electronic, mechanical or otherwise, is prohibited<br> 
  5.  without the prior written consent of the copyright owner. <br> 
  6.  ****************************************************************************************/  
  7. package com.beston.concurrency.synchronization;  
  8.   
  9. /**  
  10.  * @ClassName: SyncMethod  
  11.  * @Description: 同步方法    synchronized syncMethod(){...} 
  12.  * 作用域:某个对象实例内,可以防止多个线程同时访问这个对象的synchronized方法 
  13.  * 如果一个对象有多个synchronized方法,只要一个线 程访问了其中的一个synchronized方法, 
  14.  * 其它线程不能同时访问这个对象中任何一个synchronized方法.这时,不同的对象实例的 synchronized方法是不相干扰的。 
  15.  * 也就是说,其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法;   
  16.  * @author beston  
  17.  * @date 2014年3月17日 下午4:19:32  
  18.  * @version v1.0 
  19.  *   
  20.  */  
  21. public class SyncMethod {  
  22.       
  23.     public static void main(String[] args) {  
  24.         MethodObj obj = new MethodObj();  
  25.         //线程1执行  hello()和syncmethod1()方法   
  26.         new Thread(new Runnable1(obj)).start();  
  27.         //线程2执行  hello()和syncmethod2()方法   
  28.         new Thread(new Runnable2(obj)).start();  
  29.     }  
  30.   
  31. }  
  32. /**  
  33.  * @ClassName: Runnable1  
  34.  * @Description: 执行  hello()和syncmethod1()方法  
  35.  * @author beston  
  36.  * @date 2014年3月17日 下午4:29:49  
  37.  * @version v1.0 
  38.  *   
  39.  */   
  40. class Runnable1 implements Runnable{  
  41.     private MethodObj obj;  
  42.       
  43.     public Runnable1(MethodObj obj){  
  44.         this.obj= obj;  
  45.     }  
  46.     public  void run(){   
  47.         obj.hello();  
  48.         obj.syncmethod1();  
  49.           
  50.     }  
  51. }  
  52.   
  53. /**  
  54.  * @ClassName: Runnable2  
  55.  * @Description: 执行  hello()和syncmethod2()方法 
  56.  * @author beston  
  57.  * @date 2014年3月17日 下午4:29:07  
  58.  * @version v1.0 
  59.  *   
  60.  */   
  61. class Runnable2 implements Runnable{  
  62.     private MethodObj obj;  
  63.       
  64.     public Runnable2(MethodObj obj){  
  65.         this.obj= obj;  
  66.     }  
  67.     public  void run(){  
  68.         obj.hello();  
  69.         obj.syncmethod2();  
  70.     }  
  71. }  
  72.   
  73. class MethodObj{  
  74.       
  75.     /**  
  76.      * @Title: hello  
  77.      * @Description: 非同步,不会被锁 
  78.      */  
  79.     public void hello(){  
  80.         System.out.println(Thread.currentThread().getName()+" hello!");  
  81.   
  82.     }  
  83.       
  84.     /**  
  85.      * @Title: syncmethod1  
  86.      * @Description: 同步方法1,被第一个持有该对象的线程占用5秒 
  87.      */  
  88.     public synchronized void syncmethod1(){  
  89.         System.out.println(Thread.currentThread().getName()+" 占用 syncmethod1() 5秒");  
  90.         try {  
  91.             Thread.sleep(5000);  
  92.         } catch (InterruptedException e) {  
  93.             // TODO Auto-generated catch block  
  94.             e.printStackTrace();  
  95.         }  
  96.     }  
  97.       
  98.     /**  
  99.      * @Title: syncmethod2  
  100.      * @Description: 同步方法2 
  101.      */  
  102.     public synchronized void syncmethod2(){  
  103.         System.out.println(Thread.currentThread().getName()+" syncmethod2()");  
  104.     }  
  105. }  

2、非静态 同步块: 
2.1 
method(){ 
    synchronized (this){..}  锁对象的所有同步方法 

一个进程进入某对象同步方法后,其它线程不能同时访问这个对象中任何一个同步方法 
Java代码  收藏代码
  1. /****************************************************************************************  
  2.  Copyright © 2014 Your Company/Org. All rights reserved.<br>  
  3.  Reproduction or transmission in whole or in part, in any form or<br> 
  4.  by any means, electronic, mechanical or otherwise, is prohibited<br> 
  5.  without the prior written consent of the copyright owner. <br> 
  6.  ****************************************************************************************/  
  7. package com.beston.concurrency.synchronization;  
  8.   
  9. /**  
  10.  * @ClassName: SyncMethod  
  11.  * @Description: 同步块    synchronized(this){...} 
  12.  * 作用域: 锁定 当前对象this  
  13.  * @author beston  
  14.  * @date 2014年3月17日 下午4:19:32  
  15.  * @version v1.0 
  16.  *   
  17.  */  
  18. public class SyncThis {  
  19.       
  20.     public static void main(String[] args) {  
  21.         ThisObj obj = new ThisObj();  
  22.         //线程1执行  hello()和syncthis1()方法   
  23.         new Thread(new Runnable3(obj)).start();  
  24.         //线程2执行  hello()和syncthis2()方法   
  25.         new Thread(new Runnable4(obj)).start();  
  26.     }  
  27.   
  28. }  
  29. /**  
  30.  * @ClassName: Runnable3  
  31.  * @Description: 执行  hello()和syncthis1()方法  
  32.  * @author beston  
  33.  * @date 2014年3月17日 下午4:29:49  
  34.  * @version v1.0 
  35.  *   
  36.  */   
  37. class Runnable3 implements Runnable{  
  38.     private ThisObj obj;  
  39.       
  40.     public Runnable3(ThisObj obj){  
  41.         this.obj= obj;  
  42.     }  
  43.     public  void run(){   
  44.         obj.hello();  
  45.         obj.syncthis1();  
  46.           
  47.     }  
  48. }  
  49.   
  50. /**  
  51.  * @ClassName: Runnable4  
  52.  * @Description: 执行  hello()和syncthis2()方法 
  53.  * @author beston  
  54.  * @date 2014年3月17日 下午4:29:07  
  55.  * @version v1.0 
  56.  *   
  57.  */   
  58. class Runnable4 implements Runnable{  
  59.     private ThisObj obj;  
  60.       
  61.     public Runnable4(ThisObj obj){  
  62.         this.obj= obj;  
  63.     }  
  64.     public  void run(){  
  65.         obj.hello();  
  66.         obj.syncthis2();  
  67.     }  
  68. }  
  69.   
  70. class ThisObj{  
  71.     /**  
  72.      * @Title: hello  
  73.      * @Description: 非同步,不会被锁 
  74.      */  
  75.     public void hello(){  
  76.         System.out.println(Thread.currentThread().getName()+" hello!");  
  77.   
  78.     }  
  79.       
  80.     /**  
  81.      * @Title: syncthis1  
  82.      * @Description: 同步块1,被第一个持有该对象的线程占用5秒 
  83.      */  
  84.     public void syncthis1(){  
  85.         synchronized(this){  
  86.             System.out.println(Thread.currentThread().getName()+" 占用 syncthis1() 5秒");  
  87.             try {  
  88.                 Thread.sleep(5000);  
  89.             } catch (InterruptedException e) {  
  90.                 // TODO Auto-generated catch block  
  91.                 e.printStackTrace();  
  92.             }  
  93.         }  
  94.     }  
  95.       
  96.     /**  
  97.      * @Title: syncthis2  
  98.      * @Description: 同步块2 
  99.      */  
  100.     public void syncthis2(){  
  101.         synchronized(this){  
  102.             System.out.println(Thread.currentThread().getName()+" syncthis2()");  
  103.         }  
  104.           
  105.     }  
  106. }  

2.2 
Object obj = new Object(); 
method(){ 
    synchronized (obj){..}  锁住该代码块 

锁定非自身(this)的其他对象(如this的成员),则只锁住该代码块,本类其他同步方法不受影响 
Java代码  收藏代码
  1. /****************************************************************************************  
  2.  Copyright © 2014 Your Company/Org. All rights reserved.<br>  
  3.  Reproduction or transmission in whole or in part, in any form or<br> 
  4.  by any means, electronic, mechanical or otherwise, is prohibited<br> 
  5.  without the prior written consent of the copyright owner. <br> 
  6.  ****************************************************************************************/  
  7. package com.beston.concurrency.synchronization;  
  8.   
  9. /**  
  10.  * @ClassName: SyncBlock  
  11.  * @Description: 同步块 synchronized(obj){...}  
  12.  * 锁定非自身(this)的其他对象,则只锁住该代码块,其他同步方法不受影响 
  13.  * @author beston  
  14.  * @date 2014年3月17日 下午5:02:16  
  15.  * @version v1.0 
  16.  *   
  17.  */  
  18. public class SyncBlock {  
  19.     public static void main(String[] args) {  
  20.         BlockObj obj = new BlockObj();  
  21.         //线程1执行  hello()和syncblock1()方法   
  22.         new Thread(new Runnable5(obj)).start();  
  23.         //线程2执行  hello()和syncblock1(),syncblock2()方法   
  24.         new Thread(new Runnable6(obj)).start();  
  25.     }  
  26.   
  27. }  
  28. /**  
  29.  * @ClassName: Runnable5  
  30.  * @Description: 执行  hello()和syncblock1()方法  
  31.  * @author beston  
  32.  * @date 2014年3月17日 下午4:29:49  
  33.  * @version v1.0 
  34.  *   
  35.  */   
  36. class Runnable5 implements Runnable{  
  37.     private BlockObj obj;  
  38.       
  39.     public Runnable5(BlockObj obj){  
  40.         this.obj= obj;  
  41.     }  
  42.     public  void run(){   
  43.         obj.hello();  
  44.         obj.syncblock1();  
  45.           
  46.     }  
  47. }  
  48.   
  49. /**  
  50.  * @ClassName: Runnable6  
  51.  * @Description: 执行  hello()和syncblock1(),syncblock2()方法  
  52.  * @author beston  
  53.  * @date 2014年3月17日 下午4:29:07  
  54.  * @version v1.0 
  55.  *   
  56.  */   
  57. class Runnable6 implements Runnable{  
  58.     private BlockObj obj;  
  59.       
  60.     public Runnable6(BlockObj obj){  
  61.         this.obj= obj;  
  62.     }  
  63.     public  void run(){  
  64.         obj.hello();  
  65.         obj.syncblock2();   
  66.         obj.syncblock1();   
  67.           
  68.     }  
  69. }  
  70.   
  71. class BlockObj{  
  72.     Byte[] b = new Byte[0];  
  73.     Object a = new Object();  
  74.     int i = 0;//非对象 不能放到synchronized()括号中  
  75.     /**  
  76.      * @Title: hello  
  77.      * @Description: 非同步,不会被锁 
  78.      */  
  79.     public void hello(){  
  80.         System.out.println(Thread.currentThread().getName()+" hello!");  
  81.   
  82.     }  
  83.       
  84.     /**  
  85.      * @Title: syncblock1  
  86.      * @Description: 同步块,进入该方法线程占用5秒 
  87.      */  
  88.     public void syncblock1(){  
  89.         synchronized(a){  
  90.             System.out.println(Thread.currentThread().getName()+" 占用 syncblock1() 5秒");  
  91.             try {  
  92.                 Thread.sleep(5000);  
  93.             } catch (InterruptedException e) {  
  94.                 // TODO Auto-generated catch block  
  95.                 e.printStackTrace();  
  96.             }  
  97.         }  
  98.     }  
  99.       
  100.     /**  
  101.      * @Title: syncblock2  
  102.      * @Description: 同步块 
  103.      */  
  104.     public void syncblock2(){  
  105.         synchronized(b){  
  106.             System.out.println(Thread.currentThread().getName()+" syncblock2()");  
  107.         }  
  108.           
  109.     }  
  110. }  


3、静态 同步方法 
static synchronized method() {...} 
一个进程进入类静态同步方法后,其它线程不能同时访问这个类中静态同步方法和静态同步块,其他非静态同步方法和非静态同步块不受影响 
Java代码  收藏代码
  1. /****************************************************************************************  
  2.  Copyright © 2014 Your Company/Org. All rights reserved.<br>  
  3.  Reproduction or transmission in whole or in part, in any form or<br> 
  4.  by any means, electronic, mechanical or otherwise, is prohibited<br> 
  5.  without the prior written consent of the copyright owner. <br> 
  6.  ****************************************************************************************/  
  7. package com.beston.concurrency.synchronization;  
  8.   
  9. import java.util.logging.Logger;  
  10.   
  11. /** 
  12.  * @ClassName: SynStaticMethod 
  13.  * @Description: 结论: 不同线程访问同一个类的静态同步方法时, 线程间是互斥的.其他非静态同步块和同步方法不受影响 
  14.  * @author beston 
  15.  * @date 2014年3月17日 下午6:02:41 
  16.  * @version v1.0 
  17.  *  
  18.  */  
  19. public class SynStaticMethod {  
  20.   
  21.     // 线程1  
  22.     static class T1 implements Runnable {  
  23.         SynStaticMethod s;  
  24.   
  25.         public T1(SynStaticMethod sameObj) {  
  26.             this.s = sameObj;  
  27.         }  
  28.   
  29.         // 线程1访问静态同步方法  
  30.         public void run() {  
  31.             SynStaticMethod.syn();  
  32.         }  
  33.     }  
  34.   
  35.     // 线程2  
  36.     static class T2 implements Runnable {  
  37.         SynStaticMethod s;  
  38.   
  39.         public T2(SynStaticMethod sameObj) {  
  40.             this.s = sameObj;  
  41.         }  
  42.   
  43.         // 线程2访问静态同步方法  
  44.         public void run() {  
  45.             //SynStaticMethod.static2();不会阻塞  
  46.             //SynStaticMethod.syn2();  
  47.             //new SynStaticMethod().synInstance3();  
  48.             //new SynStaticMethod().syn();  
  49.             //SynStaticMethod.syn();  
  50.               
  51.         }  
  52.     }  
  53.   
  54.     // 对象的静态同步方法  
  55.     public static synchronized void syn() {  
  56.         String threadStr = Thread.currentThread().getName();  
  57.           
  58.         try {  
  59.             System.out.println(threadStr + "正在静态访问同步方法syn()!!!");  
  60.             Thread.sleep(3000);  
  61.         } catch (InterruptedException e) {  
  62.             e.printStackTrace();  
  63.         }  
  64.           
  65.     }  
  66.       
  67.     // 对象的静态同步方法  
  68.     public static synchronized void syn2() {  
  69.         String threadStr = Thread.currentThread().getName();  
  70.           
  71.         try {  
  72.             System.out.println(threadStr + "正在静态访问同步方法syn2()!!!");  
  73.             Thread.sleep(3000);  
  74.         } catch (InterruptedException e) {  
  75.             e.printStackTrace();  
  76.         }  
  77.           
  78.     }  
  79.       
  80.     // 对象的静态同步方法  
  81.     public synchronized void synInstance3() {  
  82.         String threadStr = Thread.currentThread().getName();  
  83.           
  84.         try {  
  85.             System.out.println(threadStr + "正在静态访问同步方法synInstance3()!!!");  
  86.             Thread.sleep(3000);  
  87.         } catch (InterruptedException e) {  
  88.             e.printStackTrace();  
  89.         }  
  90.           
  91.     }  
  92.   
  93.     // 对象的静态方法2  
  94.     public static void static2() {  
  95.         String threadStr = Thread.currentThread().getName();  
  96.           
  97.         try {  
  98.             System.out.println(threadStr + "正在静态访问方法static2()!!!");  
  99.             Thread.sleep(3000);  
  100.         } catch (InterruptedException e) {  
  101.             e.printStackTrace();  
  102.         }  
  103.           
  104.     }  
  105.   
  106.     public static void main(String[] args) {  
  107.         // 这是多线程要访问的同一个对象  
  108.         SynStaticMethod sameObj1 = new SynStaticMethod();  
  109.         SynStaticMethod sameObj2 = new SynStaticMethod();  
  110.   
  111.         // 线程1,线程2访问静态同步方法  
  112.         Thread t1 = new Thread(new T1(sameObj1));  
  113.         Thread t2 = new Thread(new T2(sameObj2));  
  114.   
  115.         t1.start();  
  116.         t2.start();  
  117.     }  
  118. }  

4、静态 同步块 
static method{ 
    synchronized (Xxx.class){..} 

一个进程进入类静态同步块后,其它线程不能同时访问这个类中所有静态同步方法和静态同步块,其他非静态同步方法和非静态同步块不受影响 
Java代码  收藏代码
  1. /****************************************************************************************  
  2.  Copyright © 2014 Your Company/Org. All rights reserved.<br>  
  3.  Reproduction or transmission in whole or in part, in any form or<br> 
  4.  by any means, electronic, mechanical or otherwise, is prohibited<br> 
  5.  without the prior written consent of the copyright owner. <br> 
  6.  ****************************************************************************************/  
  7. package com.beston.concurrency.synchronization;  
  8.   
  9. import java.util.logging.Logger;  
  10.   
  11. /** 
  12.  * @ClassName: SynStaticClass 
  13.  * @Description: 不同线程访问类的所有同步块静态方法和静态同步方法时, 线程间是互斥的.其他非静态同步块和同步方法不受影响 
  14.  * @author beston 
  15.  * @date 2014年3月17日 下午6:02:41 
  16.  * @version v1.0 
  17.  *  
  18.  */  
  19. public class SynStaticClass {  
  20.   
  21.     // 线程1  
  22.     static class T1 implements Runnable {  
  23.         SynStaticClass s;  
  24.   
  25.         public T1(SynStaticClass sameObj) {  
  26.             this.s = sameObj;  
  27.         }  
  28.   
  29.         // 线程1访问静态同步方法  
  30.         public void run() {  
  31.             SynStaticClass.syn();  
  32.         }  
  33.     }  
  34.   
  35.     // 线程2  
  36.     static class T2 implements Runnable {  
  37.         SynStaticClass s;  
  38.   
  39.         public T2(SynStaticClass sameObj) {  
  40.             this.s = sameObj;  
  41.         }  
  42.   
  43.         // 线程2访问静态同步方法  
  44.         public void run() {  
  45.             new SynStaticClass().synInstance4();//不会被阻塞  
  46.             //new SynStaticClass().syn(); //会阻塞  
  47.             //new SynStaticClass().syn3(); //会阻塞  
  48.             //SynStaticClass.syn3(); //阻塞  
  49.             //SynStaticClass.syn2(); //阻塞  
  50.             //SynStaticClass.syn();  //阻塞  
  51.         }  
  52.     }  
  53.   
  54.     // 对象的同步块静态方法  
  55.     public static void syn() {  
  56.         synchronized(SynStaticClass.class){  
  57.             String threadStr = Thread.currentThread().getName();  
  58.             try {  
  59.                 System.out.println(threadStr + "正在静态访问同步方法syn()!!!");  
  60.                 Thread.sleep(3000);  
  61.             } catch (InterruptedException e) {  
  62.                 e.printStackTrace();  
  63.             }  
  64.         }     
  65.     }  
  66.   
  67.     // 对象的同步块静态方法2  
  68.     public static void syn2() {  
  69.         synchronized (SynStaticClass.class) {  
  70.             String threadStr = Thread.currentThread().getName();  
  71.             try {  
  72.                 System.out.println(threadStr + "正在静态访问同步方法syn2()!!!");  
  73.                 Thread.sleep(3000);  
  74.             } catch (InterruptedException e) {  
  75.                 e.printStackTrace();  
  76.             }  
  77.         }  
  78.     }  
  79.       
  80.     // 对象的静态同步方法3  
  81.     public static synchronized void syn3() {  
  82.             String threadStr = Thread.currentThread().getName();  
  83.             try {  
  84.                 System.out.println(threadStr + "正在静态访问同步方法syn3()!!!");  
  85.                 Thread.sleep(3000);  
  86.             } catch (InterruptedException e) {  
  87.                 e.printStackTrace();  
  88.             }  
  89.     }  
  90.       
  91.     // 对象的同步方法3  
  92.     public synchronized void synInstance4() {  
  93.             String threadStr = Thread.currentThread().getName();  
  94.             try {  
  95.                 System.out.println(threadStr + "正在访问实例同步方法synInstance4()!!!");  
  96.                 Thread.sleep(3000);  
  97.             } catch (InterruptedException e) {  
  98.                 e.printStackTrace();  
  99.             }  
  100.     }  
  101.   
  102.     public static void main(String[] args) throws InterruptedException {  
  103.         // 这是多线程要访问的同一个类  
  104.         SynStaticClass sameObj1 = new SynStaticClass();  
  105.         SynStaticClass sameObj2 = new SynStaticClass();  
  106.   
  107.         // 线程1,线程2访问静态同步方法  
  108.         Thread t1 = new Thread(new T1(sameObj1));  
  109.         Thread t2 = new Thread(new T2(sameObj2));  
  110.   
  111.         t1.start();  
  112.         Thread.sleep(100);  
  113.         t2.start();  
  114.     }  
  115. }  
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页