2 可见性（Visibility）

2 可见性（Visibility）

并发编程的三大特性：可见性、有序性、原子性。

可见性，即当一个线程对共享变量的值修改后，能够被其他线程看到。

1. 保持可见性
   a. volatile修饰引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段的可见性；
   b. 某些语句可以触发内存缓存同步刷新: System.out.println();

/**
 * volatile 关键字，使一个变量在多个线程间可见
 * A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道
 * 使用volatile关键字，会让所有线程都会读到变量的修改值
 * 
 * 在下面的代码中，running是存在于堆内存的t对象中
 * 当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去
 * 读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行
 * 
 * 使用volatile，将会强制所有线程都去堆内存中读取running的值
 * 
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
 */
public class HelloVolatile {
    private static volatile boolean running = true;

    private static void m() {
        System.out.println("m start");
        while (running) {
            //System.out.println("hello");    // println语句具有锁机制
        }
        System.out.println("m end!");
    }

    public static void main(String[] args) {
        new Thread(T01_HelloVolatile::m, "t1").start();
        SleepHelper.sleepSeconds(1);
        running = false;
    }
}

2. 缓存行对齐
   • cache块大小 64 bytes是CPU同步的基本单位；
     1. cache越大，局部性空间效率越高，但读取时间慢；
     2. cahce越小，局部性空间效率越低，但读取时间块。
   • 缓存行隔离会比伪共享效率更高，因为此时不同核CPU的cache不用进行同步（缓存一致性协议）；
   • 缓存行隔离：
     • 缓存行隔离编程技巧

// 默认 cache 大小 64 bytes，long 占 8 bytes。
public class T01_CacheLinePadding {
    public static long COUNT = 10_0000_0000L;

    private static class T {
        private long p1, p2, p3, p4, p5, p6, p7;
        public long x = 0L;
        private long p9, p10, p11, p12, p13, p14, p15;
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        CountDownLatch latch = new CountDownLatch(2);

        Thread t1 = new Thread(()->{
            for (long i = 0; i < COUNT; i++) {
                arr[0].x = i;
            }

            latch.countDown();
        });

        Thread t2 = new Thread(()->{
            for (long i = 0; i < COUNT; i++) {
                arr[1].x = i;
            }

            latch.countDown();
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        latch.await();
        System.out.println((System.nanoTime() - start)/100_0000);
    }
}

  * **@sun.misc.Contended，**为保证缓存行隔离效果要使用此注解，必须去掉限制参数：-XX:-RestrictContended（只有1.8起作用）