我们经常说的，xxx在多线程环境下会出问题。那么究竟是什么原因会导致这些问题呢？

原子性

所谓原子性，就是不可以再被分割。对于一个具有原子性操作来说，就是在执行这个操作的过程中不会插入其他的操作

int i = 5; //原子性操作
i++; //非原子性操作
/**
* i++ 相当于 i = i + 1;
* 其中包含了三个操作：
*  1). 读取 i 的值
*  2). 对 i 加 1
*  3). 重新赋值给 i
*/

非原子性操作可能会出现的问题：比如 i 的值为1，如果在 i++ 的第二个操作的时候，有其他的线程插入进来对变量 i 做了其他的操作，那么 i++ 之后，i 的值就不会是 2 了。

可见性

可见性，就是说某个线程对于一个共享变量做了修改，其他线程能够立刻发现。

boolean flag = true;
while (flag) {
    // do something...
}
/**
* 对于这段代码，线程 A 在执行while循环。此时，线程 B 将flag的值修改为false，线程 A 能够马上退出循环操作，就说明变量flag具有可见性。
*/

共享变量未满足可见性可能会出现的问题

public class ThreadDemo {

    private static boolean flag = true;
    
    public static void main(String[] args) throws InterruptedException {
        //线程A 
        //当 flag == false 跳出循环，线程执行结束
        new Thread(() -> {
            while (flag) {
                //do something...
            }
        }).start(); 

        //防止线程B先启动
        Thread.sleep(10);

        //线程B
        //在线程A启动后，修改flag的值为false
        new Thread(() -> flag = false).start();
    }
}

此时程序不会运行结束，因为变量flag没有满足可见性，线程B对变量flag的修改操作，对于线程A是不可见的。

有序性

通俗来讲就是，代码并不一定会按照顺序来执行，java虚拟机在执行的过程中可能会改变顺序来提高性能，但是不会改变程序整体的运行结果。

(1) int a = 2; 
(2) int b = 3;
(3) int c = a + b;
(4) int d = 6;

就比如这四行代码，(3)的执行依赖于(1)和(2)，所以，虚拟机在改变执行顺序的时候，不会把(1)或者(2)放到(3)后面去执行，(4)跟其他三行没有依赖关系。最终执行的顺序是，(1)(2)一定在(3)之前执行，(4)可以在任意位置执行。这么看来似乎有序性显得不是太重要，可是在多线程的环境下就会发生问题。

//有两个线程 A B
boolean isDone = false;
//线程A
new Thread(() -> {
  save(object); //假设做保存操作
  isDone = true;
}).start();
//线程B
new Thread(() -> {
  while (true) {
    if (isDone) {
      Object obj = getObject(); 
      //使用obj对象做后续的工作 
    }
  }
}).start();

上面是一段伪代码，想表述的意思是，线程A做保存操作，然后设置标记变量isDone为true；线程B根据标记变量判断线程A是否保存完毕，当isDone == true，就认为线程A已经保存完毕，然后取出线程A保存的对象，做后续的工作。

如果此时，线程A中发生了重排序的情况，线程A里面的两行代码交换了执行的顺序。而此时，设置了isDone的值，还没有执行save操作的时候，线程B开始执行了，就会发生问题，线程B的get操作不会取到任何对象。

对于以上的三个问题，Java提供了关键字synchronized来解决。当然还有volatile以及jdk并发包里面的各种工具，后面的文章我会介绍相关的知识