`
林奇峰
  • 浏览: 42144 次
  • 性别: Icon_minigender_1
  • 来自: 濮阳
社区版块
存档分类
最新评论

线程同步总结--synchronized方法和synchronized代码块

    博客分类:
  • j2se
阅读更多

阅读前必须明白:

程序代码的目的是操作数据,而在操作数据时有可能发生同时操作同一个数据,所以为了避免同时操作一个数据产生错误才出现线程同步的概念,即synchronized方法和synchronized代码块技术。

这里的同一个数据包括 所有对象...

还有每一个对象都有一把锁,synchronized就是为此对象上锁,等到synchronized方法或synchronized代码块执行完就会自动解锁,所有多线程执行相同带synchronized的代码时会检查所操作对象是否上锁,如果已经被锁住,就阻塞等待,直到锁此代码段的线程执行完此代码块。

所以非synchronized方法不会有阻塞一说,因为它没有synchronized,所以不会检查对象锁住没有

 

 若想深入了解对象锁机制,参考http://zhangjunhd.blog.51cto.com/113473/70300

 

synchronized方法和synchronized代码块的理解:

synchronized方法锁住的是this,

synchronized(this){ },锁住this,只要多个线程同时访问同一个SynchronizedTest实例(this),就会发生不能同时访问此代码块
synchronized(Object){ },锁住Object,只要多个线程同时访问同一个Object就会发生不能同时访问此代码块

 

同步的目的就避免操作同一个数据,所以操作不同数据就不必要同步。

理解下面代码的区别,就真正理解了同步:

public class SynchronizedTest{
	
	Person p = new Person("lin", 15);
	
	public synchronized void say(){//相当于锁住this,效果和say3()一样,只要多个线程同时访问同一个SynchronizedTest实例(相当于this),就会发生不能同时访问此方法
		System.out.println(p.getName());
	}
	
	public void say2(){
		synchronized(p){//相当于锁住p,只要多个线程同时访问此代码块且是同一个p,就会发生不能同时访问此代码块锁住
			System.out.println(p.getName());
		}
	}
	
	public void say3(){
		synchronized(this){//锁住this,效果和say()一样,只要多个线程同时访问同一个SynchronizedTest实例(this),就会发生不能同时访问此代码块
			System.out.println(p.getName());
		}
	}
}

 

 

 

明白则一点,就阅读下面:

我就偷点懒,摘抄一下别人的,其实人家和我要写的差不多

以下摘自http://blog.csdn.net/xiao__gui/article/details/8188833

在Java中,synchronized关键字是用来控制线程同步的,就是在多线程的环境下,控制synchronized代码段不被多个线程同时执行。Synchronized既可以对代码块使用,也可以加在整个方法上。

 

关键是,不要认为给方法或者代码段加上synchronized就万事大吉,看下面一段代码:

[java] view plaincopy
  1. class Sync {  
  2.   
  3.     public synchronized void test() {  
  4.         System.out.println("test开始..");  
  5.         try {  
  6.             Thread.sleep(1000);  
  7.         } catch (InterruptedException e) {  
  8.             e.printStackTrace();  
  9.         }  
  10.         System.out.println("test结束..");  
  11.     }  
  12. }  
  13.   
  14. class MyThread extends Thread {  
  15.   
  16.     public void run() {  
  17.         Sync sync = new Sync();  
  18.         sync.test();  
  19.     }  
  20. }  
  21.   
  22. public class Main {  
  23.   
  24.     public static void main(String[] args) {  
  25.         for (int i = 0; i < 3; i++) {  
  26.             Thread thread = new MyThread();  
  27.             thread.start();  
  28.         }  
  29.     }  
  30. }  


 

运行结果:

test开始..

test开始..

test开始..

test结束..

test结束..

test结束..

 

可以看出来,上面的程序起了三个线程,同时运行test方法,虽然test方法加上了synchronized,但是还是同时运行起来,貌似synchronized没起作用。

 

将test方法改成如下:

[java] view plaincopy
  1. public void test() {  
  2.     synchronized(this){  
  3.         System.out.println("test开始..");  
  4.         try {  
  5.             Thread.sleep(1000);  
  6.         } catch (InterruptedException e) {  
  7.             e.printStackTrace();  
  8.         }  
  9.         System.out.println("test结束..");  
  10.     }  
  11. }  


 

运行结果:

test开始..

test开始..

test开始..

test结束..

test结束..

test结束..

 

一切还是这么平静,没有看到synchronized起到一丝作用。

 

实际上,synchronized(this)以及非staticsynchronized方法(至于static synchronized方法请往下看),只能防止多个线程同时执行同一个对象的这个代码段。

 

为什么会这样呢,回到本文的题目上:Java线程同步:synchronized锁住的是代码还是对象。答案是:synchronized锁住的是括号里的对象,而不是代码对于非静态的synchronized方法,锁的就是对象本身也就是this

 

synchronized锁住一个对象后,别的线程如果也想拿到这个对象的锁,就必须等待这个线程执行完成释放锁,才能再次给对象加锁,这样才达到线程同步的目的。

 

所以我们在用synchronized关键字的时候,能缩小代码段的范围就尽量缩小,能在代码段上加同步就不要再整个方法上加同步。这叫减小锁的粒度,使代码更大程度的并发。原因是基于以上的思想,锁的代码段太长了,别的线程是不是要等很久,等的花儿都谢了。当然这段是题外话,与本文核心思想并无太大关联。

 

再看上面的代码,每个线程中都new了一个Sync类的对象,也就是产生了三个Sync对象,由于不是同一个对象,所以可以多线程同时运行synchronized方法或代码段

 

为了验证上述的观点,修改一下代码,让三个线程使用同一个Sync的对象。

[java] view plaincopy
  1. class MyThread extends Thread {  
  2.   
  3.     private Sync sync;  
  4.   
  5.     public MyThread(Sync sync) {  
  6.         this.sync = sync;  
  7.     }  
  8.   
  9.     public void run() {  
  10.         sync.test();  
  11.     }  
  12. }  
  13.   
  14. public class Main {  
  15.   
  16.     public static void main(String[] args) {  
  17.         Sync sync = new Sync();  
  18.         for (int i = 0; i < 3; i++) {  
  19.             Thread thread = new MyThread(sync);  
  20.             thread.start();  
  21.         }  
  22.     }  
  23. }  


 

运行结果:

test开始..

test结束..

test开始..

test结束..

test开始..

test结束..

 

可以看到,此时的synchronized方法和synchronized代码段就都起了作用。

 

那么,如果真的想锁住这段代码,要怎么做?也就是,如果还是最开始的那段代码,每个线程new一个Sync对象,怎么才能让test方法不会被多线程执行。

 

解决也很简单,只要锁住同一个对象不就行了。例如,synchronized后的括号中锁一个static final对象,这样就行了。这样是没问题,但是,比较多的做法是让synchronized锁这个类对应的Class对象。

[java] view plaincopy
  1. class Sync {  
  2.   
  3.     public void test() {  
  4.         synchronized (Sync.class) {  
  5.             System.out.println("test开始..");  
  6.             try {  
  7.                 Thread.sleep(1000);  
  8.             } catch (InterruptedException e) {  
  9.                 e.printStackTrace();  
  10.             }  
  11.             System.out.println("test结束..");  
  12.         }  
  13.     }  
  14. }  
  15.   
  16. class MyThread extends Thread {  
  17.   
  18.     public void run() {  
  19.         Sync sync = new Sync();  
  20.         sync.test();  
  21.     }  
  22. }  
  23.   
  24. public class Main {  
  25.   
  26.     public static void main(String[] args) {  
  27.         for (int i = 0; i < 3; i++) {  
  28.             Thread thread = new MyThread();  
  29.             thread.start();  
  30.         }  
  31.     }  
  32. }  


 

运行结果:

test开始..

test结束..

test开始..

test结束..

test开始..

test结束..

 

上面代码用synchronized(Sync.class)实现了全局锁的效果

 

最后说说static synchronized,实际上static方法可以直接类名加方法名调用,方法里面没有this这个概念,所以,static synchronized方法也相当于全局锁,相当于锁住了代码段。

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics