### synchronized锁对象为包装类型\(修饰变量\) synchronized锁对象为包装类型时，需要考虑包装类型的缓存，如Integer默认缓存-127~128之间的数值，所以下例中锁a和锁b实际锁的是同一个对象；另外其它包装类也需要注意类似问题\(如Byte/Short\)； ``` public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } public static Short valueOf(short s) { final int offset = 128; int sAsInt = s; if (sAsInt >= -128 && sAsInt <= 127) { // must cache return ShortCache.cache[sAsInt + offset]; } return new Short(s); } ``` ``` public class ConcurrentTest { private Integer a = 100; private Integer b = 100; public static void main(String[] args) throws InterruptedException { ConcurrentTest test = new ConcurrentTest(); test.testA(); test.testB(); System.err.println("a:"+ test.a); System.err.println("b:"+ test.b); } private void testA() { new Thread(() -> { System.err.println("A thread started"); synchronized (a) { for (int i = 0; i < 10; i++) { System.err.println("a =>"); sleep(1); } } }).start(); } private void testB() { new Thread(() -> { System.err.println("B thread started"); synchronized (b){ for (int i = 0; i < 10; i++) { System.err.println("b =>"); sleep(1); } } }).start(); } } out==> //实际输出是等打印完a才打印b A thread started a => B thread started a => a => a => a => a => a => a => a => a => b => b => b => b => b => ``` 当然实际开发过程中一般也不会使用包装类做锁对象！