从底层理解并发编程

计算机组成

1、当计算机要运行一个进程的时候，CPU会把磁盘中的需要执行的进程调到内存中，调到内存后再执行进程中找到对应的Main函数(即主线程)，找到主线程后开始读指令，读到一条指令就执行一条指令

2、进程是分配资源的基本单位，线程资源执行的基本单位。

3、当线程得到的CPU时间段执行完后，需要保存对应的指令和数据就保存到cache（缓存）。当该线程获取到CPU时间的时候就开始从cache读取对应的指令和数据

从底层理解线程调度原理

由于执行切换是很耗费资源的事情，所以并不是线程越多越好

所谓的超线程就是一个ALU对应多个PC|Registers

当一个ALU对应多个PC|Registers的时候就不需要缓存

从底层理解并发编程的可见性

案例1

private static boolean running=true;
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                long i= 0L;
                while(running){
                    i++;
                }
                System.out.println("结束：i="+i);
            }
        });
        t.start();
        Thread.sleep(1000);
        running=false;
    }

运行这段代码发现该代码永远无法停止运行，这里从底层来理解并发编程的可见性问题

1、当开启一个线程来运行以上的代码的时候，它会读取一级缓存的内容，发现没有变量running就会读取二级缓存，以此类推，当读到running的值的时候就会保存到一级缓存中。

2、当主线程修改running的值的时候，它只修改一级缓存中的值，而且由于该案例中的是有两个线程来运行的，所以就导致了，子线程读到的running的值永远都是true。

3、当CPU把数据从内存读到缓存中的时候就读取一片在内存中连续的数据。相当于每次读取固定长度的数组中的数据，这个固定大小为64byte

案例2

public class T02 {
    public static long COUNT=1_0000_0000L;
    private static class T{
        public volatile long x=0L;
    }
    public static T[] arr=new T[2];
    static {
        arr[0]=new T();
        arr[1]=new T();
    }
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch=new CountDownLatch(2);
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                for(long i=0;i<COUNT;i++){
                    arr[0].x=i;
                }
                latch.countDown();
            }
        });
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                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);
    }
}

执行结果:

public class T02 {
    public static long COUNT=1_0000_0000L;
    private static class T{
        public long p1,p2,p3,p4,p5,p6,p7;
        public volatile long x=0L;
        public 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 InterruptedException {
        CountDownLatch latch=new CountDownLatch(2);
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                for(long i=0;i<COUNT;i++){
                    arr[0].x=i;
                }
                latch.countDown();
            }
        });
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                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);
    }
}

执行结果:

1、可以看到第二个程序仅在第一个程序中的public volatile long x=0L;前后添加了7个long类型的变量，第二个程序的运行速度比第一个程序快了将近四倍

2、这是由于CPU每次从内存中读取的长度是64byte，当运行第一个程序的时候，由于读取到的两个x都在同内存的同一个数据段中，这时用两个线程来修改这两个x中的值，那么由于并发编程的可见性，它就需要通知其他CPU这段中的数据修改了

3、当运行第二个程序的时候，由于public volatile long x=0L;前后添加了7个long类型的变量,由于long类型的变量占8byte，第一个x和前面的7个long类型的变量刚好是64byte，后面第二个x和后面的7个long类型的变量刚好也是64byte。这就导致了读取到的只能是其中一个x，用线程修改x的值的时候只修改了读到的x，不需要通知其他CPU这段数据修改了