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

//[e-mail]@[e-mail]@[e-mail]@[e-mail]@[e-mail]@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 来确定。