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关键字实际上是依靠对象锁的机制来实现线程同步的。