Java--深入理解JMM模型、Java并发特性

最新推荐文章于 2023-09-15 10:31:00 发布

Aruba233

最新推荐文章于 2023-09-15 10:31:00 发布

阅读量142

点赞数

分类专栏： JVM原理与多线程文章标签：多线程 java 并发编程 jvm spark

本文链接：https://blog.csdn.net/qq_24000367/article/details/120795855

版权

JVM原理与多线程专栏收录该内容

9 篇文章 1 订阅

订阅专栏

上次说到Java线程并不会直接操作共享内存，而是操作共享内存的副本，这种方式称作JMM模型，描述的是Java多线程和内存之间的通信。我们上次使用了HotSpot虚拟机的内存模型进行理解，但JMM模型并不是JVM的内存模型，两者都是一种规范，各个虚拟机都有不同的实现方式，JMM模型模仿的是CPU缓存模型

真正的JMM模型如下：

JMM模型

Java中每个线程都有自己独立的 工作内存，存在 主内存中的共享变量对所有线程都是可见的，即每个线程都能操作它，而实际上 线程操作共享变量时会把它 拷贝到自己的工作内存中， 真正操作的是共享变量的副本，操作结束后，再 写入到主内存的共享变量中 缺点：这就会导致如果两个不同的线程同时对一个共享变量操作时，出现不同步的问题，这也是Java并发的三大特性：原子性、可见性、有序性

一、八种原子操作

还记得之前使用javap命令反转义的字节码么？字节码中会将我们方法中写的代码进行细分，成为”iload、istore“等汇编指令，我们一句代码，可能会被分成很多个小的指令。同样的，JMM规定线程对共享变量的操作细分为八种，而这八种操作再也细分不了了，所以称之为原子操作
前六种原子操作为：

read：从共享变量中读取变量的数据
load：将读取的数据放入工作内存的副本中
use：将副本的数据交由执行引擎处理
assign：将执行结果赋值到副本
store：从副本中读取数据
write：将读取数据写回共享变量

结合我们上面JMM模型，如下图：

原子操作共享变量

这就是为什么多个线程对同一个对象同时进行数据操作时，会出现问题的原因：我们的数据还没来得及写回，其他线程就已经在使用它了另外两种原子操作就是为了解决这个并发问题而出现的：

lock：对共享变量进行加锁，其他线程只能进入等待队列
unlock：对共享变量进行解锁，其他线程进行竞争，获取锁对共享变量再次加锁的线程才能进入可执行状态

二、可见性问题

首先看下面的代码：

public class VolatileTest {
    public static boolean isRunning = true;

    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                try {
                    sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("isRunning:" + isRunning);
                isRunning = false;
                System.out.println("isRunning:" + isRunning);
            }
        }.start();

        while (isRunning) {

        }

        System.out.println("主线程退出");
    }
}

主线程先进入while循环，另一个线程200ms后，对isRunning赋值为false，可运行的结果并没有合我们的意，主线程一直在while循环中

原因：

主线程一直在对isRunning变量的副本做判断，而主线程的isRunning变量副本存的值，在最初读取isRunning变量时就是true，虽然另一个线程对isRunning进行了操作，并且也成功的将false写入到了变量中，但是线程的工作内存是私有的，主线程并不知道isRunning发生了改变**，所以主线程中的副本一直都是true，循环并不会退出共享变量对所有线程都可见，但线程工作内存中是私有的，里面的副本对外不可见
可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

解决方法：

volatile关键字
我们对上面的isRunning变量使用volatile关键字修饰后再运行：

public class VolatileTest {
    public static volatile boolean isRunning = true;

    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                try {
                    sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("isRunning:" + isRunning);
                isRunning = false;
                System.out.println("isRunning:" + isRunning);
            }
        }.start();

        while (isRunning) {

        }

        System.out.println("主线程退出");
    }
}

结果是可以正常退出了

原理：

缓存一致性协议中的MESI协议
MESI协议解决了可见性问题，它将变量分成四种状态：

M：修改
E：独占
S：共享
I ：失效

使用volatile修饰变量后，该变量就会遵循这种协议，细化步骤为：
1.当执行isRunning = false时，将isRunning设为独占状态，其他线程不能访问
2.修改结束后，写回isRunning，又使它成为共享状态，其他线程可以访问
3.发送数据改变消息给总线嗅探机制
4.其他线程通过总线嗅探机制接收到消息后，将副本设为失效状态
5.副本失效后，重新read load操作，读取数据到副本

上诉代码使用图解如下：

1.主线程读取共享变量：

2.其他线程改变共享变量得值：

3.触发总线嗅探机制：

三、有序性问题

先看下面代码：

package thread;

//解决有序性问题
public class VolatileTest2 {
    static int x = 0;
    static int y = 0;
    static int a = 0;
    static int b = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 10000; i++) {
            x = 0;
            y = 0;
            a = 0;
            b = 0;

            new Thread(new Runnable() {
                @Override
                public void run() {
                    x = a;
                    b = 1;
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    y = b;
                    a = 1;
                }
            }).start();

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (x == 1 && y == 1) {
                System.out.println("指令重排序出现的问题");
            }
        }
    }

}

按照正常逻辑顺序来看这块代码的话，x和y是不可能同时为1的
因为如果x为1，那么第二个线程的代码肯定执行完了，也就是y = b执行过了，此时b为0，y就一定是0
反之，y为1，x = a已经执行过了，此时a为0，x就一定是0

执行结果还是没合我们的意：

原因：

指令重排序：当一个线程中的两条代码完全不相干时，那么它们的执行顺序是可以交换的
我们以第一个线程为例子： x = a 和 b = 1 没有关联性，那么执行时，它们的顺序不一定按照我们代码所写的顺序执行，如果我们写成：a = 1 和 x = a ，那么它们会按照代码顺序执行
但是在多线程中，这就会造成问题了，由于抢占式线程调度，你不知道何时哪个线程会暂停，哪个线程会执行

解决方法：

volatile关键字修饰这些变量后，再次执行

package thread;

//解决有序性问题
public class VolatileTest2 {
    static volatile int x = 0;
    static volatile int y = 0;
    static volatile int a = 0;
    static volatile int b = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 10000; i++) {
            x = 0;
            y = 0;
            a = 0;
            b = 0;

            new Thread(new Runnable() {
                @Override
                public void run() {
                    x = a;
                    b = 1;
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    y = b;
                    a = 1;
                }
            }).start();

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (x == 1 && y == 1) {
                System.out.println("指令重排序出现的问题");
            }
        }
    }

}

这次就不会出现指令重排序了

volatile关键字不仅可以解决可见性问题，还能解决有序性问题，它就是将变量的写操作先行于读操作

四、原子性问题

先来看下面代码：

package thread;

public class VolatileTest3 {
    static int count = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 20000; i++) {
            new Thread(){
                @Override
                public void run() {
                    addCount();
                    System.out.println(count);
                    super.run();
                }
            }.start();
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static void addCount() {
        count++;
    }

}

我们开启了20000次线程，对一个整型变量进行++操作，期望结果为20000，最后执行结果为：

我们继续使用volatile修饰变量，再次执行：

解决方法：

synchronized关键字修饰方法：

package thread;

public class VolatileTest3 {
    static int count = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 20000; i++) {
            new Thread() {
                @Override
                public void run() {
                    addCount();
                    System.out.println(count);
                    super.run();
                }
            }.start();
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static synchronized void addCount() {
        count++;
    }

}

执行结果：