如何理解JAVA的多线程-创新互联

这篇文章主要介绍“如何理解JAVA的多线程”，在日常操作中，相信很多人在如何理解JAVA的多线程问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”如何理解JAVA的多线程”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于网站设计制作、成都网站设计、山城网络推广、成都小程序开发、山城网络营销、山城企业策划、山城品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们大的嘉奖；创新互联公司为所有大学生创业者提供山城建站搭建服务，24小时服务热线：13518219792，官方网址：www.cdcxhl.com

多线程

计算机存储体系

要想明白数据一致性问题，要先缕下计算机存储结构，从本地磁盘到主存到CPU缓存，也就是从硬盘到内存，到CPU。一般对应的程序的操作就是从数据库查数据到内存然后到CPU进行计算。这个描述有点粗，下边画个图。

业内画这个图一般都是画的金字塔型状，为了证明是我自己画的我画个长方型的（其实我不会画金字塔）。

CPU多个核心和内存之间为了保证内部数据一致性还有一个缓存一致性协议（MESI），MESI其实就是指令状态中的首字母。M（Modified）修改，E（Exclusive）独享、互斥，S（Shared）共享，I（Invalid）无效。然后再看下边这个图。

太细的状态流转就不作描述了，扯这么多主要是为了说明白为什么会有数据一致性问题，就是因为有这么多级的缓存，CPU的运行并不是直接操作内存而是先把内存里边的数据读到缓存，而内存的读和写操作的时候就会造成不一致的问题。解决一致性问题怎么办呢，两个思路。

1. 锁住总线，操作时锁住总线，这样效率非常低，所以考虑第二个思路。

2. 缓存一致性，每操作一次通知（一致性协议MESI），（但多线程的时候还是会有问题，后文讲）

JAVA内存模型

上边稍微扯了一下存储体系是为了在这里写一下JAVA内存模型。

Java虚拟机规范中试图定义一种Java内存模型（java Memory Model) 来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。

内存模型是内存和线程之间的交互、规则。与编译器有关，有并发有关，与处理器有关。

Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量与Java编程中所说的变量有所区别，它包括 了实例字段、静态字段和构成数组对象的元素，但不包括局部变量与方法参数，因为后者是线程私有的，不会被共享，自然就不会存在竞争问题。为了获得较好的执行效能，Java内存模型并没有限制执行引擎使用处理器特定寄存器或缓存来和主内存进行交互，也没有限制即时编译器进行调整代码执行顺序这类优化措施。

Java内存模型规定了所有的变量都存储在主内存中。每条线程还有自己的工作内存，线程的工作内存中保存了该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取，赋值等 ）都必需在工作内存中进行，而不能直接读写主内存中的变量。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。

这里所说的主内存、工作内存和Java内存区域中的Java堆、栈、方法区等并不是同一个层次的内存划分，这两者基本上是没有关系的。  如果两者一定要勉强对应起来，那从变量、主内存、工作内存的定义来看，主内存对应Java堆中的对象实例数据部分 ，而工作内存则对应于虚拟机栈中的部分区域。从更底层次上说，主内存就是直接对应于物理硬件的内存，而为了获取更好的运行速度，虚拟机可能会让工作内存优先存储于寄存器和高速缓存中，因为程序运行时主要访问读写的是工作内存。

前边说的都是和内存有关的内容，其实多线程有关系的还有指令重排序，指令重排序也会造成在多线程访问下结束和想的不一样的情况。大段的介绍就不写了要不篇幅太长了（JVM那里书里边有）。主要就是在CPU执行指令的时候会进行执行顺序的优化。画个图看一下吧。

具体理论后文再写先来点干货，直接上代码，一看就明白。

public class HappendBeforeTest {
    int a = 0;
    int b = 0;
    public static void main(String[] args) {
        HappendBeforeTest test = new HappendBeforeTest();
        Thread threada = new Thread() {
            @Override
            public void run() {
                test.a = 1;
                System.out.println("b=" + test.b);
            }
        };
        Thread threadb = new Thread() {
            @Override
            public void run() {
                test.b = 1;
                System.out.println("a=" + test.a);
            }
        };
        threada.start();
        threadb.start();
    }
}

猜猜有可能输出什么？多选

A：ａ＝０，ｂ＝１
B：ａ＝１，ｂ＝０
C：ａ＝０，ｂ＝０
D：ａ＝１，ｂ＝１

上边这段代码不太好调，然后我稍微改造了一下。

public class HappendBeforeTest {
    static int a = 0;
    static int b = 0;
    static int x = 0;
    static int y = 0;
    public static void shortWait(long interval) {
        long start = System.nanoTime();
        long end;
        do {
            end = System.nanoTime();
        }
        while (start + interval >= end);
    }
    public static void main(String[] args) throws InterruptedException {
        for (; ; ) {
            Thread threada = new Thread() {
                @Override
                public void run() {
                    a = 1;
                    x = b;
                }
            };
            Thread threadb = new Thread() {
                @Override
                public void run() {
                    b = 1;
                    y = a;
                }
            };
            Thread starta = new Thread() {
                @Override
                public void run() {
                    // 由于线程threada先启动
                    //下面这句话让它等一等线程startb
                    shortWait(100);
                    threada.start();
                }
            };
            Thread startb = new Thread() {
                @Override
                public void run() {
                    threadb.start();
                }
            };
            starta.start();
            startb.start();
            starta.join();
            startb.join();
            threada.join();
            threadb.join();
            a = 0;
            b = 0;
            System.out.print("x=" + x);
            System.out.print("y=" + y);
            if (x == 0 && y == 0) {
                break;
            }
            x = 0;
            y = 0;
            System.out.println();
        }
    }
}

这段代码，a和b初始值为0，然后两个线程同时启动分别设置a=1,x=b和b=1,y=a。这个代码里边的starta和startb线程完全是为了让threada 和threadb 两个线程尽量同时启动而加的，里边只是分别调用了threada 和threadb 两个线程。然后无限循环只要x和y 不同时等于0就初始化所有值继续循环，直到x和y都是0的时候break。你猜猜会不会break。

结果看截图

因为我没有记录循环次数，不知道循环了几次，然后触发了条件break了。从代码上看，在输出A之前必然会把B设置成1，在输出B之前必然会把A设置为1。那为什么会出现同时是零的情况呢。这就很有可能是指令被重排序了。

指令重排序简单了说是就两行以上不相干的代码在执行的时候有可能先执行的不是第一条。也就是执行顺序会被优化。

如何判断你写的代码执行顺序会不会被优化，要看代码之间有没有Happens-before关系。Happens-before就是不无需任何干涉就可以保证有有序执行，由于篇幅限制Happens-before就不在这里多做介绍。

下面简单介绍一下java里边的一个关键字volatile。volatile简单来说就是来解决重排序问题的。对一个volatile变量的写，一定happen-before后续对它的读。也就是你在写代码的时候不希望你的代码被重排序就使用volatile关键字。volatile还解决了内存可见性问题，在执行执行的时候一共有8条指令lock(锁定)、read(读取)、load(载入)、use(使用)、assign(赋值)、store(存储)、write(写入)、unlock(解锁)（篇幅限制具体指令内容自行查询，看下图大概有个了解）。

volatile主要是对其中4条指令做了处理。如下图

也就是把 load和use关联执行，把assign和store关联执行。众所周知有load必需有read现在load又和use关联也就是要在缓存中要use的时候就必须要load要load就必需要read。通俗讲就是要use(使用)一个变量的时候必需load(载入），要载入的时候必需从主内存read(读取）这样就解决了读的可见性。下面看写操作它是把assign和store做了关联，也就是在assign(赋值)后必需store(存储)。store(存储）后write(写入）。也就是做到了给一个变量赋值的时候一串关联指令直接把变量值写到主内存。就这样通过用的时候直接从主内存取，在赋值到直接写回主内存做到了内存可见性。

无锁编程

我在网上看到大部分写多线程的时候都会写到锁，AQS和线程池。由于网文太多本文就不多做介绍。下面简单写一写CAS。

CAS是一个比较魔性的操作，用的好可以让你的代码更优雅更高效。它就是无锁编程的核心。

CAS书上是这么介绍的：“CAS即Compare and Swap，是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性”。他是非阻塞的还是原子性，也就是说这玩意效率更高。还是通过硬件保证的说明这玩意更可靠。

从上图可以看出，在cas指令修改变量值的时候，先要进行值的判断，如果值和原来的值相等说明还没有被其它线程改过，则执行修改，如果被改过了，则不修改。在java里边java.util.concurrent.atomic包下边的类都使用了CAS操作。最常用的方法就是compareAndSet。其底层是调用的Unsafe类的compareAndSwap方法。

到此，关于“如何理解JAVA的多线程”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注创新互联-成都网站建设公司网站，小编会继续努力为大家带来更多实用的文章！

网页题目：如何理解JAVA的多线程-创新互联
当前网址：http://wjwzjz.com/article/degsog.html