并发编程中存在的三个问题

并发编程中存在的三个问题：原子性、可见性、有序性，这三个问题都会导致获取共享数据出错，产生并发问题

原子性

• 原子性（Atomicity）：在一次或多次操作中，要么所有的操作都执行并且不会受其他因素干扰而中断，要么所有的操作都不执行。
• 出现原子性问题的两个前提：至少有两个线程、有个共享变量
• 原子性问题：当一个线程对共享变量操作到一半时，另外的线程也可能来操作共享变量，干扰了前一个线程的操作。

public class Atomicity {

	private static int number = 0;
	
	public static void main(String[] args) throws InterruptedException {
		Runnable increment = () -> {
			for (int i = 0; i < 1000; i++) {
				number++;
			}
		};
		
		List<Thread> list = new ArrayList<Thread>();
		// 5个线程，每个线程执行1000次number++
		for (int i= 0; i < 5; i++) {
			Thread t = new Thread(increment);
			t.start();
			list.add(t);
		}
		
		//为了保证5个线程执行完毕，主线程再打印number
		for (Thread t : list) {
			t.join();
		}
		
		System.out.println("number:" + number);
	}
}

• 5个线程，每个线程执行1000次number++，最终结果应该是5000，但打印结果是“number:4130”。说明number++操作并不是原子性操作。
  • 从主内存中读取数据到工作内存
  • 对工作内存中的数据进行+1操作
  • 将工作内存中的数据写回主内存
• 对于number++（number为静态变量），通过javap命令分析java汇编指令，javap -p -v Atomicity.class，实际会产生如下JVM字节码指令

5: getstatic     #10                 // Field number:I
8: iconst_1
9: iadd
10: putstatic     #10                 // Field number:I

• number++由多条语句组成，以上多条语句在单线程的情况下是不会出问题的，但是多线程情况下，一个线程在执行9: iadd，另一个线程又执行5: getstatic，会导致两次number++，实际只加了1。

可见性

• 可见性（Visibility）：是指一个线程对共享变量进行修改，另一个线程立即得到修改后的新值。
• 出现可见性问题的两个前提：至少有两个线程、有个共享变量
• 可见性问题，一个线程对共享变量进行修改，另一个线程不能立即得到修改后的值（获取变量的值还是旧的值）

public class Visibility {
	// 共享变量
	private static boolean flag = true;
	
	public static void main(String[] args) throws InterruptedException {
		new Thread(() ->  {
			while (flag) {
				
			}
		}).start();
		
		// 等待2s,保证线程1已经读取到了flag
		Thread.sleep(2000);
		
		new Thread(() -> {
			flag = false;
			System.out.println("另一个线程修改了flag:" + flag);
		}).start();
	}
}

• 当打印 “另一个线程修改了flag:false”，程序并没有停止，也就是说，线程1获取的flag还是初始获取的true，并没有立即得到修改后的值。

有序性

• 有序性（Ordering）：是指程序中代码在执行过程中的先后顺序，java在编译和运行时会对代码进行优化，会导致程序最终执行的顺序不一定是代码编写的顺序。
• 重排序：
  

a = 1; // 操作1
b = 2; // 操作2

// 重排序后
b = 2; // 操作2
a = 1; // 操作1

• 出现可见性问题的两个前提：至少有两个线程、有个共享变量

public class Ordering {
	private int num = 0;
	private boolean flag = false;
	private int x;
	
	public void action1() {
		if (flag) {
			x = num + num;
		} else {
			x = 1;
		}
		// x的可能结果
		System.out.println(x);
	}
	
	public void action2() {
		num = 2;
		flag = true;
	}
}

• x的可能结果：
  • 结果1：线程1执行action1()，此时flag=false，x的结果为1
  • 结果2：线程2先执行了action2()，线程1再执行action1()，此时flag=true,num=2，x的结果为4
  • 结果3：java在编译和运行时会对代码进行优化，action2()的执行顺序变成了如下，此时线程2更改flag值之后，CPU切换到线程1执行，num为初始化的值0，x的结果为0

	public void action2() {
		flag = true;
		num = 2;
	}

• 上面的结果3就是有序性产出的并发问题