Synchroinzed对Integer的问题

​
先来看两段代代码：

1、

package com.thread.test.synchronize;

/**
 * Created by shamee-loop on 2020/12/6.
 */
public class SynchronizedErrorOnInteger implements Runnable {
    public static Integer count = 0;
    static SynchronizedErrorOnInteger instance = new SynchronizedErrorOnInteger();
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            synchronized (count) {
                count ++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

2、

package com.thread.test.synchronize;

/**
 * Created by shamee-loop on 2020/12/6.
 */
public class SynchronizedErrorOnInteger implements Runnable {
    public static Integer count = 0;
    static SynchronizedErrorOnInteger instance = new SynchronizedErrorOnInteger();
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            synchronized (instance) {
                count ++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

咋一看没什么区别，主线程启动2个子线程t1、t2。对count++；synchronized对临界区资源进行加锁，实现线程间同步。所以最终得到的count应该等于200000。

但是，代码段1得到的值确一直小于200000。显然没有做到线程安全。

先来看synchronized的简单应用整理：

1）指定加锁对象，对给定对象加锁，进入同步代码前要获得给定对象的锁。

2）直接作用于实例方法，相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

3）直接作用于静态方法，相当于对当前类加锁，进入同步代码前要获得当前类的锁。

那么，加在Integer和instance有什么区别呢？

我们使用javap反编译代码1：

我们看到选定的位置，在count++位置，其实真正执行的是：

count = Integer.valueOf(count.intValue() + 1);

再来看Integer.valueOf()方法：

看到return new Integer(i);这里其实是新建了一个实例，所以每次synchronized加锁可能都不是同一个对象实例，从而导致控制临界区资源出现问题。

简单的解决办法就是，如代码2。直接对instance加锁。

​