引言
一转眼已经两年多没写多博客了；一转眼也要快工作两三年了；一转眼我又开始写Java代码了。希望自己可以坚持写写博客，总结总结的习惯！加油。
今天在调试代码的时候，发现两个毫不相关的thread用jstack看竟然其中一个在等待另一个的线程持有的锁，很是奇怪。经过研究，是因为Integer类的实现机制导致的。
一、异常阻塞代码
1 package xxx;
2
3 public class TestDeadLock {
4 public static void main(String[] argvs) {
5
6 new A("threadA").start();
7 new B("threadB").start();
8 try {
9 Thread.sleep(15000);
10 } catch (Exception e) {
11
12 }
13 }
14 }
15 class A extends Thread {
16 public A(String name) {super(name);}
17 private final Object updateLock = 0;
18 @Override
19 public void run() {
20 System.out.println(updateLock.getClass());
21 synchronized (updateLock) {
22 System.out.println(System.currentTimeMillis() + " in A");
23 try {
24 sleep(100000);
25 } catch (InterruptedException e) {
26
27 }
28 }
29 }
30 }
31 class B extends Thread {
32 public B(String name) {super(name);}
33 private final Object updateLock = 0;
34 @Override
35 public void run() {
36 System.out.println(updateLock.getClass());
37 synchronized (updateLock) {
38 System.out.println(System.currentTimeMillis() + " in B");
39 try {
40 sleep(100000);
41 } catch (InterruptedException e) {
42
43 }
44 }
45 }
46 }
上面的代码很简单，建立了两个thread，分别打印一句话，每个线程拥有一个本地的变量updateLock用来进行自己线程内部的同步。问题就出在了这个updateLock上。运行上面的代码会发现这两个线程会互相阻塞，updateLock为线程的内部对象，为什么会互相阻塞呢？问题就出现在了17以及33行的0赋值的问题。0这个值本身是一个基本类型int，updateLock是一个Object的类型，因为实际上会把0强转为Integer类型赋值给updateLock对象，那么Java内部是如何完成这个操作的呢，这个赋值是依赖于Integer的ValueOf方法实现的。
二、Integer的ValueOf实现
1 public static Integer valueOf(int i) {
2 if (i >= IntegerCache.low && i <= IntegerCache.high)
3 return IntegerCache.cache[i + (-IntegerCache.low)];
4 return new Integer(i);
5 }
可以看到valueOf的实现依赖于IntegerCache的实现，从名字就能看出来IntegerCache是一个Interger的缓存，IntegerCache缓存这从-128到127(上限127可以通过jvm配置进行修改)。valueOf的逻辑就是如果存在缓存，返回缓存，不存在就返回一个新的Integer对象。
三、IntegerCache的实现
1 private static class IntegerCache {
2 static final int low = -128;
3 static final int high;
4 static final Integer cache[];
5
6 static {
7 // high value may be configured by property
8 int h = 127;
9 String integerCacheHighPropValue =
10 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
11 if (integerCacheHighPropValue != null) {
12 try {
13 int i = parseInt(integerCacheHighPropValue);
14 i = Math.max(i, 127);
15 // Maximum array size is Integer.MAX_VALUE
16 h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
17 } catch( NumberFormatException nfe) {
18 // If the property cannot be parsed into an int, ignore it.
19 }
20 }
21 high = h;
22
23 cache = new Integer[(high - low) + 1];
24 int j = low;
25 for(int k = 0; k < cache.length; k++)
26 cache[k] = new Integer(j++);
27
28 // range [-128, 127] must be interned (JLS7 5.1.7)
29 assert IntegerCache.high >= 127;
30 }
31
32 private IntegerCache() {}
33 }
IntegerCache的实现比较简单，其实就是内部维护了一个cache数组，提前new好对象，需要的时候直接返回，不再进行对象的创建，因为对象的创建成本是很高的，这样做可以提高效率。这里有一个有意思的地方是jvm需要通过java.lang.Integer.IntegerCache.high配置来修改cache缓存的上限，但是没有提供修改下限的配置，不知道这样做的目的是什么，还有待于考察。
四、深入Object updateLock = 0
因为第一节中的额代码产生了线程互相阻塞的问题，所以可以猜测出两个线程中的updateLock其实是一个相同的对象，即两个线程中的updateLock是两个相同的Integer对象，而相同的Integer对象很大可能是产生自Integer的valueOf方法返回的对象。为了验证我们的猜想，我们将断点断到java.lang.Interger的valueOf函数上进行debug，查看调用栈，如下图所示
上面的图验证了我们的猜想。因此如何解决这个问题也就很简单了。可以将一个new Object()赋值给updateLock就可以了。
总结
如果一个对象的目的是用在synchronized关键字后进行同步处理，那么不允许进行int或其他内部类型的赋值，如第一节中的示例代码，标准的做法应该如下
final Object updateLock = new Object();
原文地址：https://www.cnblogs.com/forspecialgirllearning/p/9174528.html