（一）并发编程入门

国际劫匪

已于 2024-05-08 19:05:52 修改

阅读量1.1k

点赞数 30

分类专栏：并发编程文章标签： java intellij-idea

于 2024-05-08 11:33:37 首次发布

本文链接：https://blog.csdn.net/qq_44816669/article/details/138543798

版权

并发编程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

并发编程入门

文章目录

并发编程入门
前言
一、JMM
二、并发三大特性
三、synchronized的深入理解
- 3.1. 锁原理、锁升级
- 3.2. 锁膨胀、锁消除

前言

多线程是为了提升程序的运行速度。但是，当多线程访问同一个资源的时候，会产生线程安全的问题。

一、JMM

我们先来看下代码

public class TestThreadSafe {
    boolean  flag = true;

    public static void main(String[] args) throws InterruptedException {
        TestThreadSafe t = new TestThreadSafe();
        new Thread(t::test).start();

        TimeUnit.SECONDS.sleep(1);

        t.flag = false;

    }
    void test(){
        System.out.println("start");
        while (flag){

        }
        System.out.println("end");
    }
}

大家觉得这段代码有没有问题？本地运行可以发现，程序永远也终止不了。这就不得不提JMM（Java内存模型），如下图：

在这里插入图片描述
flag 是存在主内存当中的，如果线程要用到flag这个变量，必须从主内存中copy到自己的本地内存，这样可以提高程序的运行效率。这时候，虽然线程B对flag进行了修改，也写回到了主内存，但是线程A并不知道，它拿到的依然是本地内存中的flag。

二、并发三大特性

2.1. 可见性

为了解决上述代码中的问题，我们只需要稍微修改以下代码就可以：

volatile boolean flag = true;

volatile底层通过缓存一致性协议，将线程A的本地内存中的flag标记为无效，如果需要访问flag必须重新从主内存中读取，这就是所谓的线程可见性，在汇编层面的体现上就是 lock指令。

2.2. 原子性

请观看如下代码：

public class TestThreadSafe {

    volatile int num = 0;

    public static void main(String[] args) throws InterruptedException {
        TestThreadSafe t = new TestThreadSafe();
        for (int i = 0; i < 100; i++){
            new Thread(t::test).start();
        }
        TimeUnit.SECONDS.sleep(2);
        System.out.println(t.num);
    }
    void test(){
        num++;
    }
}

大家觉得num的值一定是100吗？答案是否定的。为什么加了volatile会不行呢？通过javap反编译我们可以发现：

在这里插入图片描述

num++操作是由三个指令组成，volatile只能保证可见性，无法保证原子性（即一组操作不能被打断），我们可以通过加锁解决

public class TestThreadSafe {

    int num = 0;

    public static void main(String[] args) throws InterruptedException {
        TestThreadSafe t = new TestThreadSafe();
        for (int i = 0; i < 100; i++){
            new Thread(()->{
                synchronized (t){
                   t.test();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
        System.out.println(t.num);
    }
    void test(){
        num++;
    }
}

我们通过反编译可以观察到jvm层面的实现。

在这里插入图片描述

2.3. 指令重排序

我们都知道在单例模式中，有一种双重检查锁的创建方式，代码如下：

public class TestThreadSafe {
    private static TestThreadSafe instance;

    private TestThreadSafe() {
    }

    public static TestThreadSafe getInstance() {
        if (instance == null) {
            synchronized (TestThreadSafe.class) {
                if (instance == null) {
                    instance = new TestThreadSafe();
                }
            }
        }
        return instance;
    }
}

要知道其中的问题，我们首先得知道，创建对象一共分为三个步骤：

1：在内存中开辟一块空间
2：赋值
3：返回地址

那么在jvm执行过程中，它会发现第2步和第3步满足happens-before原则（即指令之间互不相关），那么很有可能是先返回地址再对内存空间进行赋值。如果出现这种情况，其他线程拿到的对象虽然不为空，但是里面根本就没有属性值，所以其他线程在操作的时候就会有问题。为了避免这种情况，需要将单例对象用volatile进行修饰。

volatile保证指令不可重排序的原理是通过内存屏障去解决。

三、synchronized的深入理解

3.1. 锁原理、锁升级

我们都知道，synchronized锁的是对象，那么对象到底在内存中是什么样的布局呢？我们可以通过以下方法直观看到：

        <dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.9</version>
        </dependency>