标签：
【内容简介】
本文主要介绍Java中如何正确的使用synchronized关键字实现线程的互斥锁。
【能力需求】
至少已经完整的掌握了Java的语法基础，基本的面向对象知识，及创建并启动线程。
【正文】
关于synchronized关键字的使用，很多说法是“锁同一个对象”就可以确保锁是正常的，今天，有人提了一个问题，我觉得非常不错，所以与各位一起分享一下。
在这里，就不提关于线程和synchronized关键字的基本使用了，以非常传统的“银行取钱”的故事为案例，直接上代码：
Ps：以下代码是直接敲的，不是在IDE工具中复制出来的，可能存在敲错的地方，请见谅。
public class ThreadSample {
public static Object lock = new Object();
public static int money = 1000;
public static void main(String args) {
Card card1 = new Card();
Card card2 = new Card();
card1.start();
card2.start();
}
}
class Card extends Thread {
public void run() {
synchronize(ThreadSample.lock) {
if(ThreadSample.money >= 800) {
ThreadSample.money -= 800;
System.out.println("取款成功，余额：" + ThreadSample.money);
} else {
System.out.println("余额不足，取款失败！");
}
}
}
}
以上代码是模拟取钱的，使用static成员money表示帐户，所以保证了多个线程访问到的是同一个值，同时，基于static成员是唯一且具有共享特性的，以上代码中使用static成员lock用于synchronized锁定，这个做法是可行的，所以，在很多人的观点里会认为“锁的是同一个对象就可以实现锁定”。
但是，有人测试出了以下这样的代码并提问（忽略掉相同的代码片段）：
class Card extends Thread {
public Integer i = 1;
public void run() {
synchronize(i) {
if(ThreadSample.money >= 800) {
ThreadSample.money -= 800;
System.out.println("取款成功，余额：" + ThreadSample.money);
} else {
System.out.println("余额不足，取款失败！");
}
}
}
}
写到这里，我不得不发自内心的再说一句，他作为一名第1次学习到线程的人，提出这样的问题，肯定是非常优秀的！
以上代码，在Card中声明了public Integer i = 1;并使用这个Integer对象作为synchronized锁的对象，最后，锁定也是成功的。
如果参考此前所说的“锁的是同一个对象就可以实现锁定”，那么，从代码里可以看到，运行过程中创建了2个Card对象，那么这2个Card对象有各自的Integer i成员，锁的就不是同一个对象，却也成功的锁定了，所以，此前的说法是不贴切的！
也许会有人说Integer或类似的包装类很特殊，也许是对应的int这些基本数据类型在作祟，那么，以下代码仍然是可行的：
class Card extends Thread {
public String str = "www.tedu.cn";
public void run() {
synchronize(str) {
if(ThreadSample.money >= 800) {
ThreadSample.money -= 800;
System.out.println("取款成功，余额：" + ThreadSample.money);
} else {
System.out.println("余额不足，取款失败！");
}
}
}
}
好了，用String也是可以锁的，那就跟基本数据类型没有关系了，下一步的解释会是什么呢？先别着急，再来看一段代码：
public class ThreadSample {
public static int money = 1000;
public static void main(String args) {
Integer i1 = 1;
Integer i2 = 1;
Card card1 = new Card(i1);
Card card2 = new Card(i2);
card1.start();
card2.start();
}
}
class Card extends Thread {
public Integer i;
public Card(Integer i) {
this.i = i;
}
public void run() {
synchronize(i) {
if(ThreadSample.money >= 800) {
ThreadSample.money -= 800;
System.out.println("取款成功，余额：" + ThreadSample.money);
} else {
System.out.println("余额不足，取款失败！");
}
}
}
}
以上代码中，在Card中添加了带参数的构造方法，为成员Integer i赋值，并使用成员Integer i来实现锁定，并且，在运行线程之前，分别声明了Integer i1和Integer i2用于创建Card对象，结果，锁定依然是可行的。
如果有兴趣的话，可以把以上代码中的Integer换成String，可以发现，仍然还是可行的！
在这里，已经很明显了，在运行线程之前，声明了不同的对象用于创建Card对象，不管是Integer类型还是String类型，都是可行的！
那么，应该怎么解释这个问题呢？也许会有人想到equals()和hashCode()，是不是equals()对比出true，并且hashCode()值相同，就可以呢？这个想法是错的，请看以下代码：
public class ThreadSample {
public static int money = 1000;
public static void main(String args) {
long timeMillis = System.currentTimeMillis();
Date d1 = new Date(timeMillis);
Date d2 = new Date(timeMillis);
Card card1 = new Card(d1);
Card card2 = new Card(d2);
card1.start();
card2.start();
}
}
我们都知道Date类是重写了equals()和hashCode()的，以上代码中的d1和d2表示的时间完全相同，所以，d1和d2的equals()对比结果为true，且hashCode()返回值是相同的，但是，以上代码却不能成功的实现锁定！
看完了以上这么纠结的问题，最后总结一下答案，通俗一点来说：如果使用==判断结果为true，就可以用于synchronize锁定！
比如，在使用String测试的时候，声明以下2个String类型的数据：
String str1 = "www.cnblogs.com"; String str2 = "www.cnblogs.com";
分别使用以上2个对象创建Card，并在Card中声明String成员用于锁定，结果是OK的，但是，以下代码就不行：
String str1 = "www.cnblogs.com"; String str2 = ""; str2 += "www.cnblogs.com";
尽管组成字符是相同的，但是，str1是直接使用常量赋值的，对应的数据保存在字符串常量池中，而str2最后是通过变量运算出来的，是运行期得到的结果，对应的数据将位于堆内存中，所以，在栈内存中保存的str1和str2的引用并不相同，也就是str1 == str2的结果为false，所以，这样来锁是失败的！
上述关于String的第1段代码中，是在编译期使用String常量赋值给str1和str2，由于字符串常量池中的字符串是唯一的，所以str1、str2使用==时的结果将是true，至于Integer这些包装类，内部是通过诸多static成员来实现的，基于static的特性，所以上述代码中的i1、i2使用==判断时的结果也会是true。
所以，关于synchronized锁的对象，学术化的定义可以是“对象在栈内存中的引用相同，就是同一个对象，就可以用于锁”，通俗的表达就是“使用==判断为true就可以用于锁”，因为使用==判断其实就是判断栈内存中存储的数据。
【小结】
用于synchronized锁的对象，如果可以存在2个，并使用==判断的结果为true，就可以用于锁！
如果本文有不足或者错误的地方，欢迎随时指出，如需转载，请注明出处，Thank you ！
标签：
原文地址：http://www.cnblogs.com/soul-wing/p/5572677.html
