目录
本文为个人学习笔记，一切内容仅供参考。
一、可见性（visibility）
1.用 volatile 保障可见性
可见性：
被 volatile 修饰的内存，对所有线程可见。
线程每一次使用被 volatile 修饰的变量时，都需要去内存中重新读取一遍该变量的值。
代码：
public class Main {
private static volatile boolean running = true;
private static void m() {
System.out.println("m start!");
while (running) {}
System.out.println("m end!");
}
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
Main.m();
}, "t1").start();
TimeUnit.SECONDS.sleep(1);
running = false;
}
} 在上例中，如果 running 不用 volatile 修饰，则在 main 线程中修改其值后，并不会影响 t1 线程中 copy 到的 running 的值，线程会一直循环运行。
volatile 修饰引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段（成员变量）的可见性。
2.某些语句会触发可见性机制
某些语句内部带有 synchronized，可以触发可见性，如：println()。
这些语句会触发内存缓存同步刷新：可以将线程本地的缓存和主内存之间的数据进行刷新与同步。
二、有序性（ordering）
1.语句乱序执行的现象
举例：
提高 CPU 的执行效率：CPU 的处理速度远大于寄存器，当指令 1 去读取数据时，需要等待很长的时间，这个时候 CPU 就可能会先去执行指令 2 做计算。
前提：前后两条语句没有依赖关系，如：x = 1; x++; 就不会发生乱序。
as-if-serial：不论在计算机底层实际是谁先执行，都不会影响单线程的最终一致性。
如果在多线程环境下发生乱序，则可能会造成一些不好的影响。
代码：
public class Main {
private static boolean ready = false;
private static int number;
private static class MyThread extends Thread {
@Override
public void run() {
while (!ready) {
Thread.yield();
}
System.out.println(number);
}
}
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
// 下面这两条语句没有依赖关系，可能会发生乱序执行
number = 42;
ready = true;
}
} 分析：
在类初始化时，会先给静态变量赋初值，即 number = 0。
若发生了语句的乱序执行，即若 ready = true 先执行，则此时的 number 还没被初始化就会被打印。
最后打印的 number 可能是 42 或 0。
2.this 对象逸出的现象
代码：
public class Main {
private int num = 8;
public Main() {
new Thread(() -> {
System.out.println(num);
}).start();
}
public static void main(String[] args) {
new Main();
}
}分析：
在对象初始化的过程中，可能会先将对象（this）与内存空间建立关联，再调用构造方法对成员变量进行初始化。
在构造方法还未执行完时，可能会先启动线程，然后打印输出还未初始化的变量值 num = 0。
对象的创建过程详见：。
解决方法：不要在构造方法中启动线程（但是可以创建线程），可以单独写一个方法用于启动线程。
3.阻止乱序的方式：内存屏障
内存屏障的含义：是一种特殊的指令，其前面的指令必须执行完，后面的才能执行。
JVM 内存屏障：
volatile 底层使用内存屏障实现：
volatile 读 = 读数据 + LoadLoadBarrier + LoadStoreBarrier
volatile 写 = LoadStoreBarrier + 写数据 + StoreLoadBarrier
volatile：
使用 volatile 可以保证可见性。
使用 volatile 可以保证有序性。
三、原子性（atomicity）
1.什么是原子性操作？
原子性操作：不能被其它线程打断，不能与其它线程一起并发执行的操作。
代码：
public class Main {
private static long n = 0L;
public static void main(String[] args) throws InterruptedException {
Thread[] t = new Thread[100];
CountDownLatch latch = new CountDownLatch(t.length);
for (int i = 0; i < t.length; i++) {
t[i] = new Thread(() -> {
for (int j = 0; j < 10000; j++) {
n++;
}
latch.countDown();
});
}
for (int k = 0; k < t.length; k++) {
t[k].start();
}
// 阻塞，等待所有线程执行完毕后再打印n的值
latch.await();
System.out.println(n);
}
} 理论结果为：1 000 000。
实际结果为：122 507。
原因：多个线程访问同一个共享数据时会产生竞争，可能会造成数据的不一致（并发访问之下产生的不期望出现的结果）。
如何解决这个问题？
用 synchronized 上锁保证原子性：
可以将 n++ 这条语句用 synchronized(Main.class) 上锁来实现线程同步（保障数据一致性）。
上锁的本质就是把并发编程序列化。
用 synchronized 也可以保证可见性，上例中每次 n++ 完以后，一定会与主内存做同步。
用 synchronized 不能保证有序性，其内部的语句仍然可能出现乱序重排的现象。
2.如何保证操作的原子性？
（1）悲观锁
含义：悲观地认为这个操作会被别的线程打断。
（2）乐观锁
含义：乐观地认为这个操作不会被别的线程打断，又叫做无锁、自旋锁（使用 CAS 实现）。
CAS（compare and swap / exchange / set）
CAS 原理：
当这里的值 E、V 为普通的数据类型时，不用考虑 ABA 问题；但如果是引用类型，则需要加 version 来解决 ABA 问题。
version 可以由带时间戳、数字或布尔类型变量等方式来实现。
CAS 自身必须保证原子性。
代码：
public class Main {
// 设置初始值为0
AtomicInteger count = new AtomicInteger(0);
static CountDownLatch latch = new CountDownLatch(100);
void run() {
for (int i = 0; i < 10000; i++) {
// count++
count.incrementAndGet();
}
latch.countDown();
System.out.println(Thread.currentThread().getName() + ":" + count);
}
public static void main(String[] args) throws InterruptedException {
Main m = new Main();
List<Thread> t = new ArrayList<>();
for (int i = 0; i < 100; i++) {
t.add(new Thread(m::run, "thread-" + i));
}
// 启动所有线程
t.forEach((o) -> o.start());
latch.await();
System.out.println(m.count); // 1000000
}
}分析：
AtomicInteger 可以保证原子性，用于对 int 类型的数据进行原子性的访问，此时的访问是加了锁的。
AtomicXxx：通过 CAS 实现，一般会比直接用 synchronized 上锁效率更高。
incrementAndGet()：实现线程安全的自增（原子性操作）。
其他保证原子性的类：AtomicLong、LongAdder（效率：LongAdder > AtomicLong > Sync）。
CAS 底层实现：
由 CPU 原语（指令级别）支持。
底层还是通过上锁实现的（汇编指令：lock cmpxchg），不允许其他 CPU（线程）打断当前对某块内存的 CAS 操作（单核 CPU 没必要上锁）。
（3）总结
基本概念补充：
critical section（临界区，即被锁住的代码）：
若临界区的执行时间长，语句多，就叫锁的粒度比较粗。
若临界区的执行时间短，语句少，就叫锁的粒度比较细。可以使线程争用时间变短，从而提高效率。
悲观锁与乐观锁的效率对比：
悲观锁：
有一个等待队列，等待中的线程不消耗 CPU 的资源。
适用场景：临界区执行时间长，且等待线程很多。
乐观锁：
所有线程会一直循环地去访问数据，这些线程都是活着的，需要线程间的调度，会消耗 CPU 的资源。
适用场景：临界区执行时间短，且等待线程数少。
