Java的锁机制

原文地址：http://blog.csdn.net/yangzhijun_cau/article/details/6432216

        一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在Java里边就是拿到某个同步对象的锁（一个对象只有一把锁）； 如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。 取到锁后，他就开始执行同步代码(被synchronized修饰的代码）；线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中等待的某个线程就可以拿到锁执行同步代码了。这样就保证了同步代码在统一时刻只有一个线程在执行。

关于线程的同步，一般有以下解决方法：
1. 在需要同步的方法的方法签名中加入synchronized关键字。
2. 使用synchronized块对需要进行同步的代码段进行同步。
3. 使用JDK 5中提供的java.util.concurrent.lock包中的Lock对象。

让我们从JVM的角度来看看锁这个概念：
在Java程序运行时环境中，JVM需要对两类线程共享的数据进行协调：
1）保存在堆中的实例变量
2）保存在方法区中的类变量
这两类数据是被所有线程共享的。（程序不需要协调保存在Java 栈当中的数据。因为这些数据是属于拥有该栈的线程所私有的。）
在java虚拟机中，每个对象和类在逻辑上都是和一个监视器相关联的。对于对象来说，相关联的监视器保护对象的实例变量。对于类来说，监视器保护类的类变量。（如果一个对象没有实例变量，或者一个类没有变量，相关联的监视器就什么也不监视。） 
为了实现监视器的排他性监视能力，java虚拟机为每一个对象和类都关联一个锁。代表任何时候只允许一个线程拥有的特权。线程访问实例变量或者类变量不需锁。但是如果线程获取了锁，那么在它释放这个锁之前，就没有其他线程可以获取同样数据的锁了。（锁住一个对象就是获取对象相关联的监视器）

类锁实际上用对象锁来实现。当虚拟机装载一个class文件的时候，它就会创建一个java.lang.Class类的实例。当锁住一个对象的时候，实际上锁住的是那个类的Class对象。
一个线程可以多次对同一个对象上锁。对于每一个对象，java虚拟机维护一个加锁计数器，线程每获得一次该对象，计数器就加1，每释放一次，计数器就减 1，当计数器值为0时，锁就被完全释放了。

示例一：

1. public class ThreadTest extends Thread {   
2.     private int threadNo;   
3.     public ThreadTest(int threadNo) {   
4.         this.threadNo = threadNo;   
5.     }   
6.     public static void main(String[] args) throws Exception {   
7.         for (int i = 1; i < 10; i++) {   
8.            new ThreadTest(i).start();   
9.             Thread.sleep(1);   
10.         }   
11.      }   
12.     
13.     @Override  
14.      public synchronized void run() {   
15.         for (int i = 1; i < 10000; i++) {   
16.             System.out.println("No." + threadNo + ":" + i);   
17.         }   
18.      }   
19.  }   

      这个程序其实就是让10个线程在控制台上数数，从1数到9999。理想情况下，我们希望看到一个线程数完，然后才是另一个线程开始数数。但是这个程序的执行过程告诉我们，这些线程还是乱糟糟的在那里抢着报数，丝毫没有任何规矩可言。
     但是细心的读者注意到：run方法还是加了一个synchronized关键字的，按道理说，这些线程应该可以一个接一个的执行这个run方法才对。
     对于一个成员方法加synchronized关键字，这实际上是以这个成员方法所在的对象本身作为对象锁。在本例中，就是 以ThreadTest类的一个具体对象，也就是该线程自身作为对象锁的。一共十个线程，每个线程持有自己线程对象的那个对象锁。这必然不能产生同步的效果。换句话说，如果要对这些线程进行同步，那么这些线程所持有的对象锁应当是共享且唯一的！ 

示例二：

1. public class ThreadTest2 extends Thread {   
2.  private int threadNo; private String lock;   
3.  public ThreadTest2(int threadNo, String lock) {   
4.   this.threadNo = threadNo;   
5.      this.lock = lock;   }   
6. public static void main(String[] args) throws Exception {   
7.    String lock = new String("lock");   
8.      for (int i = 1; i < 10; i++) {     
9.   new ThreadTest2(i, lock).start();   
10.       Thread.sleep(1);   
11.      }   
12.   }     
13. public void run() {     
14.  synchronized (lock) {   
15.       for (int i = 1; i < 10000; i++) {   
16.        System.out.println("No." + threadNo + ":" + i);   
17.     }      
18.  }     
19.  }   
20.  }  

        我们注意到，该程序通过在main方法启动10个线程之前，创建了一个String类型的对象。并通过ThreadTest2的构造函数，将这个对象赋值 给每一个ThreadTest2线程对象中的私有变量lock。根据Java方法的传值特点，我们知道，这些线程的lock变量实际上指向的是堆内存中的 同一个区域，即存放main函数中的lock变量的区域。
        程序将原来run方法前的synchronized关键字去掉，换用了run方法中的一个synchronized块来实现。这个同步块的对象锁，就是 main方法中创建的那个String对象。换句话说，他们指向的是同一个String类型的对象，对象锁是共享且唯一的！
于是，我们看到了预期的效果：10个线程不再是争先恐后的报数了，而是一个接一个的报数。

示例三：

1 public class ThreadTest3 extends Thread {   

  3      private int threadNo;      4      private String lock;      5       6      public ThreadTest3( int threadNo) {      7          this.threadNo = threadNo;      8     }      9     10      public static void main(String[] args)  throws Exception {    11         12          for ( int i =  1; i <  20; i++) {    13              new ThreadTest3(i).start();    14             Thread.sleep( 1);    15         }    16     }    17     18      public static synchronized void abc( int threadNo) {    19          for ( int i =  1; i <  10000; i++) {    20                21                 System.out.println( "No." + threadNo +  ":" + i);            22         }    23     }    24     25      public void run() {    36         abc(threadNo);    27     }    28 }  

细心的读者发现了：这段代码没有使用main方法中创建的String对象作为这10个线程的线程锁。而是通过在run方法中调用本线程中一个静态的同步 方法abc而实现了线程的同步。我想看到这里，你们应该很困惑：这里synchronized静态方法是用什么来做对象锁的呢？
我们知道，对于同步静态方法，对象锁就是该静态方法所在的类的Class实例，由于在JVM中，所有被加载的类都有唯一的类对象，具体到本例，就是唯一的 ThreadTest3.class对象。不管我们创建了该类的多少实例，但是它的类实例仍然是一个！

这样我们就知道了：
1、对于同步的方法或者代码块来说，必须获得对象锁才能够进入同步方法或者代码块进行操作；
2、如果采用method级别的同步，则对象锁即为method所在的对象，如果是静态方法，对象锁即指method所在的Class对象(唯一)；
3、对于代码块，对象锁即指synchronized(abc)中的abc；
如果是同步代码块，则对象锁需要编程人员自己指定，一般有些代码为synchronized(this)只有在单例模式才生效；（本类的实例有且只有一个）
如果是同步方法，则分静态和非静态两种 。静态方法则一定会同步，非静态方法需在单例模式才生效，推荐用静态方法(不用担心是否单例)。