Synchronized说：给我一把锁，我能创造一个规矩

以下总结摘自（加上一点自己的理解）：http://blog.csdn.net/yangzhijun_cau/article/details/6432216

1.为什么有多线程同步？Java中多线程同步的机制是什么？

    当多个线程同时竞争同一资源时候，为了防止出现数据不一致性问题，需要有同步机制。而同步机制是通过锁的概念来实现的。

2.JVM对哪类线程共享的数据进行加锁机制？

   1）保存在堆中的实例变量---对象锁，就是有一个和对象相关联的监视器

    2）保存在方法区的类变量---类锁实际上用对象锁来实现，当JVM装载一个class文件时候，他会创建一个java.lang.class类的实例。所以类锁锁住的是那个类的Class对象。相应的也会有一个类对象监视器

3.何时上锁？

    这里对象锁是Java虚拟机内部使用，在Java程序中只要使用synchronized块或者synchronized方法就可以标志一个监视区域，当每次进入一个监视区域时，JVM都会自动锁上对象或者类。

4.多线程同步时，所持有的对象锁有什么要求？

   共享且唯一的

5.实例验证线程同步时，锁持有的是都为同一对象锁？只有是唯一共享的对象锁，多线程才能实现同步哦

//10个线程在控制台上数数，从1数到9999。理想情况下，我们希望看到一个线程数完，然后才是另一个线程开始数数。

实例1如下

public class ThreadTest extends Thread {   
    private int threadNo;   
    public ThreadTest(int threadNo) {   
        this.threadNo = threadNo;   
    }   
    public static void main(String[] args) throws Exception {   
        for (int i = 1; i < 10; i++) {   
           new ThreadTest(i).start();   
            Thread.sleep(1);   
        }   
     }   
    
    @Override  
     public synchronized void run() {   
        for (int i = 1; i < 10000; i++) {   
            System.out.println("No." + threadNo + ":" + i);   
        }   
     }   
 }   

结果程序并没有按照顺序报数。但是程序中已经使用了synchronized关键字了呀，这是怎么回事？首先这是一个ThreadTest实例对象锁，而在main方法中，共产生了十个实例对象，每个线程都持有自己对象的那个对象锁，因此不能实现同步效果。

实例2

public class ThreadTest2 extends Thread {   
 private int threadNo; private String lock;   
 public ThreadTest2(int threadNo, String lock) {   
  this.threadNo = threadNo;   
     this.lock = lock;   }   
public static void main(String[] args) throws Exception {   
   String lock = new String("lock");   
     for (int i = 1; i < 10; i++) {     
  new ThreadTest2(i, lock).start();   
      Thread.sleep(1);   
     }   
  }     
public void run() {     
 synchronized (lock) {   
      for (int i = 1; i < 10000; i++) {   
       System.out.println("No." + threadNo + ":" + i);   
    }      
 }     
 }   
 }  

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

实例3

 public class ThreadTest3 extends Thread {   

 2    
 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而实现了线程的同步。这里synchroniaed静态方法是用类实例（唯一）来做对象锁的。

于是，对于synchronized我们知道：

1、对于同步的方法或者代码块来说，必须获得对象锁才能够进入同步方法或者代码块进行操作；
2、如果采用method级别的同步，则对象锁即为method所在的对象，如果是静态方法，对象锁即指method所在的Class对象(唯一)；
3、对于代码块，对象锁即指synchronized(abc)中的abc；
4、对于第一种情况，对象锁即为每一个线程对象，因此有多个，所以同步失效，第二种共用同一个对象锁lock，因此同步生效，第三个因为是static，因此对象锁为ThreadTest3的class 对象，因此同步生效。

如上述正确，则同步有两种方式，同步块和同步方法

如果是同步代码块，则对象锁需要编程人员自己指定，一般有些代码为synchronized(this)只有在单态模式才生效；（本类的实例有且只有一个）

如果是同步方法，则分静态和非静态两种 。

静态方法则一定会同步，非静态方法需在单例模式才生效，推荐用静态方法(不用担心是否单例)。

在Java多线程编程中，最常见的synchronized关键字实际上是依靠对象锁的机制来实现线程同步的。