synchronized锁不住？

当synchronized遇上基本类型的封装类型对象时，锁不住？

不废话，上代码

public class Test {
    static Integer lock = new Integer(1);
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread("mu1"){
            @Override
            public void run() {
                synchronized(lock){
                    lock++;
                    try {
                        Thread.sleep(100000);
                        System.out.println("线程1休眠100s");
                    } catch (Exception e) {
                    }
                }
            }
        };
        thread1.start();
        //让线程1能够运行lock++操作，此时，lock实际是新的对象了，所以synchronized锁住的对象跟原来的对象不是同一个
        Thread.sleep(1000);
        Thread thread2 = new Thread("mu2"){
            @Override
            public void run() {
                synchronized(lock){
                    System.out.println("线程2直接运行");
                    //休眠线程，执行jstck检查两个线程是否锁住同一个对象
                    try {
                        Thread.sleep(100000);
                        System.out.println("线程2休眠100s");
                    } catch (Exception e) {
                    }
                }
            }
        };
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(lock);
    }
}

注意：代码中的Thread.sleep(1000)，这里的作用是让线程1能够修改lock对象的值，即执行lock++，这里的作用实际是相当于lock=new Integer(lock+1);

通过命令行来验证一下事实是不是这样的呢，看下图

很明显，线程1和线程2的locked对象确实不同一个，所以在锁住基本类型的对应的封装类型对象时，最好使用final来限制它的值不要被修改到，避免锁不住的情况！