1.线程不安全的原因

2.synchronized和volatile

2.1 synchronized

2.1.1 synchornized的特性

2.1.2 synchronized使用示例

2.2 volatile

我们先来看一段代码：

分析以上代码，t1和t2这两个线程的任务都是分别将count这个变量自增5000次，最后由主线程将count的值输出。很显然，t1和t2这两个线程都对count这个变量自增5000次的话，那最终的count的值就是10000.我们运行于一下代码，看是否与预期相同：

为什么不是10000呢，这就与我们的线程安全有关了。

这段代码的逻辑很简单，但是忽略了线程的安全性问题。以上代码涉及到多个线程对同一个变量counter.count的修改.我们要知道对一个变量进行修改一般有三条指令：

变量从内存中读到某个寄存器上
对变量进行操作
将变量从寄存器读回到内存中

那么以上代码就可以用如下图来表示其运行时的某种状态:

因为操作系统的随机调度,导致t1线程可能刚把count=0读取到寄存器上还没开始修改写回时,t2线程就被操作系统安排上了cpu,导致读取到的数据也是count=0,最后当两个线程将其数据分别写回后,内存中count的值就为1.这也就是为什么那段代码的运行结果与预期不符.

1.线程不安全的原因

操作系统的随机调度:这个是造成线程不安全的最根本原因,我们人为也不好去解决.
多线程同时修改同一个变量:多个线程针对同一个线程进行修改,例如以上代码.
修改操作不是原子性的:所谓原子操作是指不会被线程调度机制打断的操作.以上代码t1和t2线程对变量的修改操作就不是原子的,例如t1线程还没有将数据修改完写回内存,t2线程就开始读取、修改。
内存不可见：可见性是指一个线程对共享变量值修改后，其他线程能够从内存中去读取而不是从当前CPU的寄存器或高速缓存中读取。反之不可见就是内存中的数据可能已经被某个线程改了，但某些线程仍然在寄存器或高速缓存中读取未修改之前的数据。这样就会导致线程不安全。

内存可见性分析：

线程之间的共享变量存在内存中。然后每个线程都有一个自己的“工作内存”(也就是寄存器和高速缓存)。
当某个线程要读取一个共享变量时，会先把变量从内存中拷贝到自己的“工作内存”中，然后从“工作内存”中读取数据；
当某个线程要修改某个变量时，会直接从自己的“工作内存”去读取之前拷贝的副本，修改后在同步给内存。这样直接在自己的“工作内存”中访问数据虽然可以加快读取速度，但是却存在读错数据的风险，因为无法确定现在线程自己的“工作内存”中的数据是否和主内存中的数据一致.有可能主内存的数据已经被其他线程改了。

所以我们经常说线程安全的可见性是指：一个线程对共享变量值修改后，其他线程能够及时发现，然后从内存中去读取数据，而不是从当前CPU的寄存器或高速缓存中读取。

指令重排序:这里的"序"是指CPU中指令执行的顺序，也就是一条条汇编指令执行的顺序。指令重排序是指CPU会在执行指令前进行优化，即对指令顺序做了调整.指令的重排序也会导致线程不安全。

编译器对指令重排序的前提是”保持逻辑不发生变化“，这一点在单线程下很容易判断。但是在多线程下就很难了。多线程的代码执行复杂程度高，编译器很难在编译阶段对代码的执行效果进行预测，因此很容易导致优化后的逻辑和之前不等价.

有序性涉及到CPU以及编译器的一些底层工作原理，就不做过多解释了。

2.synchronized和volatile

2.1 synchronized

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

进入synchronized修饰的代码块，相当于对这段代码进行加锁；
退出synchronized 修饰的代码块，相当于对这段代码进行解锁。

就是当t1线程先调用这个被synchronized修饰的方法时，该线程就会获得这把锁，然后进行读取内存，自增，写回内存这些操作。线程走完了这段代码才会将锁打开。而其他线程在t1这个线程获得锁的期间中，不能访问这段代码，只能阻塞等待，直到t1线程释放锁，才能在操作系统的分配下再去竞争这把锁。也就是说，当一个线程获得锁之后，其他线程再想获得这把锁只能阻塞等待，直到这个线程将锁释放。

这时再运行代码时，结果就如预期了：

此期间synchornized的工作过程如下：

获得互斥锁
从内存中读取数据副本
将数据进行修改
将修改后的数据写入内存
释放互斥锁

2.1.1 synchornized的特性

互斥：synchornized会起到互斥的效果，某个线程执行到某个对象的synchronized中时，其它线程如果也执行到这个对象的synchronized时，就会阻塞等待。
可重入：可重入锁的内部，包含了 "线程持有者" 和 "计数器" 两个信息。

可重入：

若某个线程加锁的时候，发现锁已经被占用，而占用者恰好是自己，那么仍然可以继续获取到锁，并让计数器自增。解锁的时候计数器递减为0，释放锁。

synchronized可以保证线程的原子性，使线程更安全。

2.1.2 synchronized使用示例

1).修饰普通方法：对Demo对象加锁

2).修饰静态方法：对Demo类对象加锁

3).修饰代码块：明确指定锁哪个对象，锁当前对象

4).锁类对象

我们始终要明白，synchronized锁的究竟是什么。只有当多个线程竞争同一把锁时，才会产生阻塞等待。而多个线程竞争多个不同的锁时，不会发生竞争。

2.2 volatile

我们说线程的安全性有原子性，可见性，有序性。volatile这个关键字就可以实现线程安全的可见性。上面说了，CPU在读取内存中的数据时，会将数据先读到自己的“工作内存（CPU的寄存器和高速缓存）”上，然后CPU直接与“工作内存”上的数据打交道。但是如果频繁的读取内存，频繁的从内存上读到“工作内存”上的数据都相同的话，那么CPU为了优化速率，可能就不会每次都从内存开始读起，而是直接在“工作内存”上读取。因为直接读寄存器会比读内存要快很多。但是这样就容易导致如果其他线程改了内存上的数据，该线程不能及时知道，还在读寄存器或高速缓存。而volatile关键字就能保证让CPU每次都去读内存。这样就能及时直到内存上去读取数据，但是每次都从内存上去读取数据的话，会导致效率大大降低。

现在我们通过以下代码来了解一下volatile关键字的用法及作用：

分析以上代码，我们不难看出，我们可以通过在t2线程中输一入个非0整数来改变Test.flag的值，从而使t1线程结束循环。我们来运行一下代码：

显然，当我们输入一个非0整数后，程序还没结束运行，说明t1线程还没结束循环。为什么呢，很简单，这就涉及到了之前说过的内存可见性问题。因为在输入非0整数时，t1线程可能已经循环了千万次，每一次循环从内存上读到的Test.flag都不变，于是CPU就进行优化，不再每次都从内存中读取了，而是直接从寄存器或高数缓存上去读取数据。但是之后如果其它线程将内存上的Test.flag修改之后，当前线程还不知道，还在一直读寄存器或高数缓存的数据，这样就会导致循环不能及时停止。所以就出现了以上代码的情况。而我们用volatile关键字对Test.flag这个变量修饰后，就能强制让CPU每次读取这个数据时，都是先从内存中去读取，这样可以达到了内存可见性的要求。修改代码如下：

再来运行一下：

这样就达到预期了。