先来看两段代代码：
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加锁。
