Java并发编程的3个特性

一、原子性

原子行：即一个或者多个操作作为一个整体，要么全部执行，要么都不执行，并且操作在执行过程中不会被线程调度机制打断；而且这种操作一旦开始，就一直运行到结束，中间不会有任何上下文切换（context switch）。

我们用银行账户转账问题来形象的解释一下原子性（当然银行账户转账涉及到的问题比较多，我们这里只是来比拟一下）

举例一：
比如张三向李四转账200元，可以分解成如下步骤：
1）从张三账户减去200元
2）给李四账户加上200元
如果只执行步骤1），没有执行步骤2），问题就来了，张三说他给李四转钱了，李四说他没收到，银行该怎么处理这个事情呢？将该操作加上原子性就可以很好的解决转账问题。

举例二：
在java开发中我们经常使用如下语句

int i = 0;   //语句1
i++;         //语句2

语句1是一个原子性操作。

语句2的分解步骤是：
1）获取 i 的值；
2）计算 i + 1 的值；
3）将 i + 1 的值赋给 i;
执行以上3个步骤的时候是可以进行线程切换的，因此语句2不是一个原子性操作

二、可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看到修改的值。

举例：

private int i = 0;
private int j = 0;
//线程1
i = 10;

//线程2
j = i;

线程1修改i的值为10时的执行步骤：
1）将10赋给线程1工作内存中的 i 变量；
2）将线程1工作内存中的 i 变量的值赋给主内存中的 i 变量;

当线程2执行j = i时，线程2的执行步骤：
1）将主内存中的 i 变量的值读取到线程2的工作内存中；
2）将主内存中的 j 变量的值读取到线程2的工作内存中；
3）将线程2工作内存中的 i 变量的值赋给线程2工作内存中的 j 变量；
4）将线程2工作内存中的 j 变量的值赋给主内存中的 j 变量;

如果线程1执行完步骤1，线程2开始执行，此时主内存中 i 变量的值仍然为 0，那么线程2获取到的 i 变量的值为 0，而不是 10。

这就是可见性问题，线程1对 i 变量做了修改之后，线程2没有立即看到线程1修改的值。

三、有序性

有序性：即程序执行的顺序按照代码的先后顺序执行。

举例一：

int i = 0;
int j = 0;
i = 10;   //语句1
j = 1;    //语句2

语句可能的执行顺序如下：
1）语句1 语句2
2）语句2 语句1

语句1一定在语句2前面执行吗？答案是否定的，这里可能会发生执行重排（Instruction
Reorder）。一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序在单线程环境下最终执行结果和代码顺序执行的结果是一致的。

比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

举例二：

int i = 0;    //语句1
int j = 0;    //语句2
i = i + 10;   //语句3
j = i * i;    //语句4

语句可能的执行顺序如下：
1）语句1 语句2 语句3 语句4
2）语句2 语句1 语句3 语句4
3）语句1 语句3 语句2 语句4

语句3是不可能在语句4之后执行的，因为编译器在进行指令重排时会考虑数据的依赖性问题，语句4依赖于语句3，因此语句3一定在语句4之前执行。

接下来我们说一下多线程环境。

举例三：

private boolean flag = false;
private Context context = null;
//线程1
context = loadContext();  //语句1
flag = true;              //语句2

//线程2
while(!flag){
    Thread.sleep(1000L);
}
dowork(context);

语句可能的执行顺序如下：
1）语句1 语句2
2）语句2 语句1

由于在线程1中语句1、语句2是没有依赖性的，所以可能会出现指令重排。如果发生了指令重排，线程1先执行语句2，这时候线程2开始执行，此时flag值为true，因此线程2继续执行dowrk(context)，此时context并没有初始化，因此就会导致程序错误。

因此可以得出结论，指令重排不会影响单线程的执行结果，但是会影响多线程并发执行的结果正确性。

总结：一个正确执行的并发程序，必须具备原子性、可见性、有序性。否则就有可能导致程序运行结果不正确，甚至引起死循环。