线程安全问题的原因和解决方案

1.线程安全的概念

线程安全的确切定义是复杂的，但我们可以这样认为：

如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线 程安全的。

我们来看一段代码：

public class Demo13 {
    static class Counter {
        public int count = 0;
        void increase() {
            count++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

运行结果如下：

 我们猜想的结果是10000，可是多次运行的结果都是在6000多。所以我们也能想到，上述代码线程是不安全的。

2.线程不安全的原因

修改共享数据

上面的线程不安全代码中，涉及到多个线程针对counter.count变量进行修改，此时这个counter.count是一个多个线程都能访问到的"共享数据"。

原子性

我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还没有出来；B是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。

我们该如何解决这个问题呢？如果我们给房间加一把锁，当A进去后就把门锁上，其他人就进不来了，这样就保证了这段代码的原子性。

如果不保证原子性，一个线程在对一个变量操作，中途其他线程插入进来，如果这个操作被打断了，结果就可能是错误的。

可见性

可见性，指一个线程对共享变量值的修改，能够及时被其他线程看到。

代码顺序性

一段代码是这样的：

1. 去前台取下U盘
2. 去寝室休息20分钟
3. 去前台取下快递

如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如：按1->3->2的方式执行，也是没问题，可以少跑一次前台，这种叫做指令重排序。

3.解决方案

synchronized关键字

synchronized的特性

1.互斥

synchronized会起到互斥效果，某个线程执行到某个对象的synchronized中时，其他线程如果也执行到同一个对象，synchronized就会阻塞等待。

• 进入synchronized修饰的代码块，相当于加锁
• 退出synchronized修饰的代码快，相当于解锁

2.刷新内存

synchronized的工作过程：

• 获得互斥锁
• 从主内存拷贝变量的最新副本到工作的内存
• 执行代码
• 将更改后的共享变量的值刷新到主内存
• 释放互斥锁

3.可重入

synchronized同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的情况。

在可重入锁的内部，包含了“线程持有者”和“计数器”两个信息

• 如果某个线程加锁时，发现锁已经被占用，但恰好是自己占用的，那么仍然可以继续获取到锁，并让计数器自增
• 解锁的时候计数器递减为0，才真正释放锁（才能被别的线程获取到）

synchronized使用示例

• 直接修饰普通方法：

public class Test {
    public synchronized void methond() {
   }
}

• 修饰静态方法

public class Test {
    public synchronized static void method() {
   }
}

• 修饰代码块

锁当前对象

public class Test {
    public void method() {
        synchronized (this) {
            
       }
   }
}

锁类对象

public class Test {
    public void method() {
        synchronized (Test.class) {
       }
   }
}