1.线程安全示例

class Count{
    int a = 0;
    public void add(){
        a++;
    }
}
public class ThreadDemo8 {
    public static void main(String[] args) {
        Count count = new Count();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5_0000; i++) {
                count.add();
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5_0000; i++) {
                count.add();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(count.a);
    }
}

对于变量a是希望通过两个for循环自增到100000，但是运行结果达不到预期：

 

每一次的运行结果都是不稳定的，这就是多线程到来的问题。对上述问题进行图解（load、add、save）：

对于自增操作，本质上要分为三步：

1.先把内存中的值,读取到CPU的寄存器中（load）

2.把 CPU寄存器里的数值进行＋1运算（add）

3.把得到的结果写会到内存中（save）

如果是两个线程并发的执行count++，此时就相当于两组load add save进行执行.此时不同的线程调度顺序就可能会产生一些结果上的差异。

2.原因分析

线程安全问题的原因有如下：

1.根本原因：线程都是抢占式执行的，随机调度的。

2.代码结构原因：多个线程同时修改同一个变量。在有些时候，是可以通过调整代码结构来避免的。一个线程修改一个变量是没问题的，多个线程读取同一个变量也是没有问题的，多个线程修改不同的变量也是没问题的。

3.原子性：如果修改操作是原子性的，就可以避免了，比如把上述的load、add和save包装成一个整体就是ok的。针对线程安全问题，最主要的解决手段也是从原子性这个方面进行入手的。

4.内存可见性问题：如果一个线程读，一个线程修改，那么此时读取的结果可能不如预期值。

5.指令重排序：本质上是编译器优化出bug了，编译器有些时候会保证在代码逻辑不变的情况下对代码进行调整，那么有可能会把代码的执行顺序给调整了，很可能会带来问题。

3.如何解决？

用synchronized进行加锁：

进了方法就会加锁，出了方法就会解锁。如果是多个线程同时都在尝试加锁，那么最终只会有一个线程加锁成功，其他线程只能阻塞等待（BLOCKED）。加锁的本质就是把并发变成串行。加锁之后的运行结果：

4.关于synchronized的用法

1.修饰方法

修饰方法包括了修饰修饰普通方法和修饰静态方法，这两者的加锁对象是不同的。修饰普通方法，锁对象就是this；修饰静态方法，锁对象就是类对象（Count1.class）。

2.修饰代码块

修饰代码块就是手动指定锁对象。

总之，在加锁前，我们要明确执行对哪个对象加锁，如果多个线程针对同一个对象加锁,会产生阻塞等待(锁竞争/锁冲突)；如果多个线程针对不同对象加锁,不会阻塞等待(不会锁冲突/锁竞争)。