synchronized理解

打个比方：一个对象object就像一个大房子，大门永远打开。房子里有 很多房间（也就是方法）。

这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙

可以打开所有上锁的房间。

另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这

些东西之间如何作用的。

在此我们先来明确一下我们的前提条件。该对象至少有一个synchronized方法，否则这个key还有啥意义。当然也就

不会有我们的这个主题了。

一个人想进入某间上了锁的房间，他来到房子门口，看见钥匙在那儿（说明暂时还没有其他人要使用上锁的 房间）。

于是他走上去拿到了钥匙

，并且按照自己 的计划使用那些房间。注意一点，他每次使用完一次上锁的房间后会马上把钥匙还回去。即使他要连

续使用两间上锁的房间，

中间他也要把钥匙还回去，再取回来。

因此，普通情况下钥匙的使用原则是：“随用随借，用完即还。”

这时其他人可以不受限制的使用那些不上锁的房间，一个人用一间可以，两个人用一间也可以，没限制。但是如果当

某个人想要进入上锁的房

间，他就要跑到大门口去看看了。有钥匙当然拿了就走，没有的话，就只能等了。

要是很多人在等这把钥匙，等钥匙还回来以后，谁会优先得到钥匙？Not guaranteed。象前面例子里那个想连续使

用两个上锁房间的家伙，他

中间还钥匙的时候如果还有其他人在等钥匙，那么没有任何保证这家伙能再次拿到。 （JAVA规范在很多地方都明确

说明不保证，象

Thread.sleep()休息后多久会返回运行，相同优先权的线程那个首先被执行，当要访问对象的锁被 释放后处于等待

池的多个线程哪个会优先得

synchronzed有两类，一种是同步方法，另一种是同步代码块。无论synchronized关键字加在方法上还是对象上，他取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

同步方法：

public void method() 
{ 
synchronized (this)      //  (1) 
{ 
       //….. 
} 
} 
<span style="font-family: Helvetica, Tahoma, Arial, sans-serif; font-size: 14px; line-height: 25.2px;">处的this指的是什么呢？他指的就是调用这个方法的对象</span>

同步块示例

public void method(SomeObject so) { 
synchronized(so) 
{ 
       //….. 
} 
} <span style="font-family: Helvetica, Tahoma, Arial, sans-serif; font-size: 14px; line-height: 25.2px;">这时，锁就是so这个对象，谁拿到这个锁谁就能够运行他所控制的那段代码。当有一个明确的对象作为锁时，就能够这样写程式，但当没有明确的对象作为锁，只是想让一段代码同步时，能够创建一个特别的instance变量（他得是个对象）</span>

我们注意看下面的程序：

<span style="font-size: 14px;">public class Test implements Runnable {  
    private int i = 10;  
    private void sale(){  
       </span><span style="font-size:32px;"><em><strong> Object o = new Object(); </strong></em></span><span style="font-size: 14px;"> //这里的o对象每次调用时都会创建，所以会有很多锁，达不到我们想要的效果
        while (true) {  
            synchronized(o){  
                if (i >0){  
                    System.out.println(Thread.currentThread() + "正在卖第" + i + "张票");  
                    i--;  
                }else  
break;            
            }  
        }  
    }  
  
    @Override  
    public void run() {  
        sale();  
    }  
      
    public static void main(String[] args) {  
            Test t = new Test();  
            Thread t1 = new Thread(t);  
            Thread t2 = new Thread(t);  
            t1.start();  
            t2.start();  
            Thread.yield();  
    }  
}</span>

我们将对象的生成换下位置如下所示

public class Test implements Runnable {  
    private int i = 10;  
    <strong><span style="font-size:18px;"><em>Object o = new Object();</em></span></strong>// 通常使用：/*static*/ byte[] lock = new byte[0];  一个实例只会有一个O对象，所以只有一把锁。
    private void sale(){  
        while (true) {  
            try {  
                Thread.sleep(10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            synchronized(o){  
                if (i >0){  
                      
                    System.out.println(Thread.currentThread() + "正在卖第" + i + "张票");  
                    i--;  
                }else  
                    break;  
            }  
        }  
    }  
  
    @Override  
    public void run() {  
        sale();  
    }  
      
    public static void main(String[] args) {  
            Test t = new Test();  
            Thread t1 = new Thread(t);  
            Thread t2 = new Thread(t);  
            t1.start();  
            t2.start();  
            Thread.yield();  
    } 

但是对不同对象来说有时候synchronized来说有时候并不能达到我们想要的效果：

<pre name="code" class="java">public class Test implements Runnable{       
    @Override    
    public void run() {    
        f();  
    }    
    public synchronized void f(){  
    	for (int i = 0; i < 5; i++) {
    		System.out.println(this);  
		}
        
    }  
   
    public static void main(String[] args) {    
        Test t1=new Test();    
        Test t2=new Test();    
        // f()里面的代码无法达到同步的目的  
        new Thread(t1).start();    
        new Thread(t2).start();    
    }    
}  

//mmm.Test@71b61023
mmm.Test@123b0b7a
mmm.Test@123b0b7a
mmm.Test@71b61023
mmm.Test@123b0b7a
mmm.Test@71b61023
mmm.Test@123b0b7a
mmm.Test@71b61023
mmm.Test@123b0b7a
mmm.Test@71b61023

但是我们如果改为如下对类加锁就会正常

public class Test implements Runnable{       
    @Override    
    public  void run() {    
    	synchronized(Test.class){
        f();}  
    }    
    public  void f(){  
    	for(int i=0;i<5;i++){
    		System.out.println(this);  
    	}
    }  
   
    public static void main(String[] args) {    
        Test t1=new Test();    
        Test t2=new Test();    
        // f()里面的代码无法达到同步的目的  
        new Thread(t1).start();    
        new Thread(t2).start();    
    }    
}

用 类名.class 来确定。