并发编程-线程安全性之原子性

已于 2022-09-24 18:27:03 修改
阅读量170 收藏
点赞数
分类专栏： 并发编程 文章标签： java
于 2022-09-24 18:24:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45538589/article/details/127028922
版权

并发编程带来的挑战之同步锁

文章目录

以下是学习中的一些笔记记录，如果有错误希望得到你的指正~ 同时也希望对你有点帮助~

如果多个线程在做同一个事情的时候，可能发生线程安全性问题

  • 原子性 Synchronized、AtomicXXX、Lock
  • 可见性 Synchronized、Volatile
  • 有序性 Synchronized、Volatile

原子性问题

在下面这个例子中，有两个线程，每个线程对变量进行自增 10000次

/**
 * 线程的原子性
 *
 * @author zdp
 */
public class ThreadAtomicityClass {

        int var = 0;

        public void incr() {
            var++;
        }

        public static void main(String[] args) {
            ThreadAtomicityClass demo = new ThreadAtomicityClass();
            Thread[] threads = new Thread[2];
            for (int j = 0; j < 2; j++) {
                threads[j] = new Thread(() -> {
                    // 创建两个线程
                    for (int k = 0; k < 10000; k++) {
                        // 每个线程跑10000次
                        demo.incr();
                    }
                });
                threads[j].start();
            }
            try {
                threads[0].join();
                threads[1].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(demo.var);
        }

}

结果最后输出却小于 20000，这是因为在inc() 方法中 var++ 这个操作不是原子性的，这是因为 var++ 是属于Java高级语言中的编程指令，而这些指令 最终可能会有多条CPU指令来组成，而var++ 最终会生成3条指令，通过

javap -v ThreadAtomicityClass.class 可以查看到 inc() 方法的字节码指令如下：

  public void incr();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: dup
         2: getfield      #2   // 访问变量 var Field var:I
         5: iconst_1		   // 将整型常量 1 放入操作数栈
         6: iadd			   // 把操作数栈中的常量1出栈并相加，将相加的结果放入操作数栈
         7: putfield      #2   // 访问类字段（类变量），复制给ThreadAtomicityClass.var 这个变量
        10: return
      LineNumberTable:
        line 13: 0
        line 14: 10
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  this   Lcom/zdp/thread/thread_safety/ThreadAtomicityClass;

var++ 这个操作，如果要满足原子性，那么就需要保证某个线程在执行这个指令时，不允许其他线程干扰，现在我们没有做其他限制操作，实际上会导致这个原子性的问题发生。
一个CPU核心在同一时刻只能执行一个线程，如果线程数量远远大于CPU核心数，就会发生线程的切换，这个切换动作可以发生在任何一条CPU指令执行完之前，对于var++这三个CPU指令来说，如果线程A在执行指令 var = 0 之后执行了线程切换，这时切换到了线程B，线程B同样执行 var = 0 的操作，紧接着执行 var++，最终整个代码执行完，就会导致最终结果 是1，而不是 2。
这就是在多线程环境下，存在的原子性问题。从上面图中表面上看是多个线程对于同一个变量的操作，实际上是var++这行代码，它不是原子的，所以才导致在多线程环境出现这样的问题。也就是说我们只需要保证，var++这个指令在运行期间，在同一时刻只能由一个线程来访问，就可以解决问题。通过AutomicXXX、Lock、Synchroized都可以解决原子性问题，下面引入Synchroized 同步锁来解决

/**
 * 线程的原子性
 *
 * @author zdp
 */
public class ThreadAtomicityClass {

        //=======================synchronized start============================
        int var = 0;
        
        public void incr() {
            synchronized (this) {
                var++;
            }
        }
        //=======================synchronized end==============================

        //=======================Lock start============================
        //private final Lock lock = new ReentrantLock();
        //
        //public void incr() {
        //    lock.lock();
        //    var++;
        //    lock.unlock();
        //}
        //=======================Lock end==============================


        //=======================AtomicXXX start============================
        //public final AtomicInteger var = new AtomicInteger(0);
        //
        //public void incr() {
        //    //var.addAndGet(1);
        //    //var.incrementAndGet();
        //    var.getAndIncrement();
        //}
        //=======================AtomicXXX end==============================
        public static void main(String[] args) {
            ThreadAtomicityClass demo = new ThreadAtomicityClass();
            Thread[] threads = new Thread[2];
            for (int j = 0; j < 2; j++) {
                threads[j] = new Thread(() -> {
                    // 创建两个线程
                    for (int k = 0; k < 10000; k++) {
                        // 每个线程跑10000次
                        demo.incr();
                    }
                });
                threads[j].start();
            }
            try {
                threads[0].join();
                threads[1].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(demo.var);
        }

}

同步锁Synchronized

synchronized作用范围

  • 修饰实例方法
  • 静态方法
  • 修饰代码块

可以控制锁的作用范围

抢占锁的本质是什么？

就是互斥，如何实现互斥？

  • 得有共享资源
  • 互斥的条件可以是一个标记 0 表示无锁 1表示 有锁

对象的作用域表示了锁的作用域，既然synchronized是通过对象来控制锁的，那么锁相关的信息（锁标记等信息）一定存储在这个对象中

synchronized(ThreadAtomicityClass){}

这就引出了MarkWord对象头

MarkWord对象头

对象头，简单理解就是一个对象在JVM内存中的布局或者存储的形式。在Hotspot虚拟机中，对象在内存中的存储布局，可以分为三个区域：对象头（Header）、实例数据（Instance Data）、对齐填充 4个字节（Padding）
mark-word: 对象标记字段占4个字节，用于存储一些列的标记位，比如哈希值，轻量级锁的标记位，偏向锁标记位、分代年龄等信息
Klass Pointer： Class对象的类型指针，Jdk8默认开启指针压缩后为4个字节，关闭指针压缩 -xx:-UseCompressedOops 后，长度为8字节。其指向的位置是对象对应的Class对象（其对应的元数据对象）的内存地址
实例数据: 包括对象的所有成员变量，大小由各个成员变量决定，比如： byte 占1个字节8比特位，int占4个字节 32比特位
对齐填充： 最后这段空间补全并非必须，仅仅为了起到占位符的作用。由于HotSpot虚拟机的内存管理系统要求对象其实地址必须是8字节的整数倍，所以对象头正好是8字节的倍数。因此当对象实例数据部分没有对齐的话，就需要通过对齐填充来补全

  • 在64位的虚拟机中，要求对象占用的字节数必须是8的倍数，如果不是8的倍数，将填充成8的倍数
  • 对齐填充是为了读取数据的性能问题

ClassLayout打印对象的内存布局

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

public class LayoutClassTest {

    public static void main(String[] args) {
        //构建一个实例
        LayoutClassTest obj = new LayoutClassTest();
        //打印对象内存布局信息
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}


 OFFSET SIZE   TYPE DESCRIPTION            VALUE
  // 存储对象头，在第一个字节的后三位，会存储锁相关的信息，倒数第三位是偏向锁标志位
  0    4  (object header)  01 00 00 00 (00000001 00000000 00000000 00000000) (1)
  4    4  (object header)  00 00 00 00 (00000000 00000000 00000000 00000000) (0)
     
  // 存储Kalss Pointer类型指针
  8    4  (object header)  05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     
  //对齐填充，保证对象占用字节数是8的倍数
  12   4  (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

Synchronized锁升级

在Jdk1.6之前，只有无锁和重量级锁的概念，Jdk1.6引入了偏向锁和轻量级锁

  • 无锁

  • 偏向锁 （默认延迟开启）

    • 假设A线程进入同步代码块，没有线程竞争的情况下，会偏向A线程（当前线程指针会指向的是偏向的线程 (线程A)），下一次A线程不需要去竞争锁就可以直接进入同步代码块

  • 轻量级锁 (无锁化实现)

    • 存在多个线程竞争的情况，当线程B想要进入同步代码块，发现锁已经偏向线程A，等到A线程到达一个全局的安全点 (所有指令执行完成)，此时会升级为轻量级锁
      • 在升级为轻量级锁之后，因为线程通常执行是很快的，B会通过自旋锁的方式（-xx: PreBlockSpin = ? 可以修改自旋次数）来尝试获得锁，通过自旋锁自旋重试是为了避免线程A、B阻塞唤醒带来更大的开销
      • 在自旋（1.6优化为自适应自旋 ）的代码中去不断修改lock_flag的标记，使用CAS来完成
      • 在尝试重试自旋一定次数之后，仍无法抢占到锁，那么会升级为重量级锁，B线程会阻塞，将阻塞线程B添加到阻塞队列，这个添加到阻塞队列的动作是由ObjectMonitor对象监视器来完成的，阻塞逻辑在Monitor中实现
    • 轻量级锁避免线程阻塞

  • 重量级锁

    • 重量级锁通过LockSupport.park() 来进行阻塞，涉及用户态到内核态 (需要内核发送指令来完成的动作) 的交换

    • 没有获得锁的线程会被阻塞，获得锁之后再被唤醒

    • 重量级锁对性能消耗比较大

不同锁状态下的对象头信息

锁状态偏向锁标记位锁标记位锁标记位
无锁001
偏向锁101
轻量级锁00
重量级锁10
轻量级锁
public class LightweightLockClass {

    final static Object lock = new Object();

    public static void main(String[] args) {
        System.out.println("未加锁前的MarkWord对象头信息................");
        System.out.println(ClassLayout.parseInstance(lock).toPrintable());
        System.out.println("加锁后的MarkWord对象头信息................");
        synchronized (lock){
            System.out.println(ClassLayout.parseInstance(lock).toPrintable());
        }
    }
}

//未加锁前的MarkWord对象头信息................
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000/**[001]*/ 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

//加锁后的MarkWord对象头信息................
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           70 f6 4a 03 (01110/**[000]*/ 11110110 01001010 00000011) (55244400)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

上面加锁后直接是轻量级锁而不是偏向锁是因为默认情况下偏向锁是延迟开启的，延迟开启是因为当前程序启动的时候会有一些默认线程的启动，这些线程中会有同步代码，这些线程会造成锁的竞争，可以用-XX:BiasedLockingStartupDelay=0来关闭偏向锁的延迟开启，下面是关闭延迟开启的对象头信息：

//未加锁前的MarkWord对象头信息................
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000/**[101]*/ 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

//加锁后的MarkWord对象头信息................
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 58 9e 02 (00000/**[101]*/ 01011000 10011110 00000010) (43931653)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

这里加锁前后都是偏向锁是因为偏向锁打开状态下，默认会有配置匿名的对象获得偏向锁

重量级锁
public class HeavyLockClass {

    final static Object lock = new Object();

    public static void main(String[] args) {
        System.out.println("未加锁前的MarkWord对象头信息................");
        System.out.println(ClassLayout.parseInstance(lock).toPrintable());

        new Thread(() -> {
            synchronized (lock){
                System.out.println("子线程 加锁后的MarkWord对象头信息................");
                System.out.println(ClassLayout.parseInstance(lock).toPrintable());
            }
        }).start();

        synchronized (lock){
            System.out.println("mian 线程 加锁后的MarkWord对象头信息................");
            System.out.println(ClassLayout.parseInstance(lock).toPrintable());
        }
    }

}


//未加锁前的MarkWord对象头信息................
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000/**[001]*/ 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

//mian 线程 加锁后的MarkWord对象头信息................
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           aa 63 66 1c (10101/**[010]*/ 01100011 01100110 00011100) (476472234)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

//子线程 加锁后的MarkWord对象头信息................
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           aa 63 66 1c (10101/**[010]*/ 01100011 01100110 00011100) (476472234)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

由于Main线程对lock锁的竞争，导致锁升级为重量级锁

CAS (CompareAndSwap)

在锁涉及的相关操作中，以下操作必须是原子的：

  • 修改锁的标记
  • 修改线程指针的指向

CAS就是比较并交换的意思，它可以保证在多线程环境下对于一个变量修改的原子性

CAS包括三个值 原始值，预期值，更新值，如果原始值 == 预期值，那么就更新值

CAS 返回值

  • true ：修改成功
  • false ：修改失败

轻量级锁中修改锁标志位实现

//自旋锁
for(;;){
    //（自旋次数控制避免一直修改失败）
    if(CAS){
        //修改锁标志位
        break;
    }
}

CAS 保证原子性

  • 使用CPU层面的锁来控制，多核情况下会增加一个Lock指令 (缓存锁/总线锁)
CAS ABA问题

通过版本号解决

扶我起来！我还能码！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解内核阻塞与唤醒进程
m0_73494896的博客
09-17 779
MMC： cpu内存管理单元物理内存： 内存条的内存空间虚拟内存： 使得程序认为自己拥有连续的可用的内存，实际上，通常是被分割成多个物理内存碎片，还有部分暂时存储在外部磁盘存储上。页面文件： 操作系统反映使用虚拟内存的硬盘空间大小而创建的文件。缺页中断： 用户程序访问已经映射在虚拟地址空间中，但未被加载到物理内存的一个分页时，由MMC发出的中断。虚拟内存空间进行分页产生页（page），物理内存地址空间进行分页产生页帧（page frame），页和页帧大小一样。
并发-锁的介绍与实践
weixin_37589770的博客
09-16 124
Q1:Java有哪几种锁？ 在java技术中，尝尝听到下列关于锁的名词，在应用开发层面，都是基于synchronized和ReentrantLock的集成或实现。 公平锁/非公平锁 公平锁是指多个线程按照申请锁的顺序来获取锁。 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。 对于Java ReentrantLock而言，通过构造函数指定...
JUC 七. LockSupport 线程的阻塞与唤醒
qq_29799655的博客
05-14 80
目录一. LockSupport 基础二. 阻塞与唤醒线程的集中方式wait() 与 notify() 方式JUC包下 Condition 中的 await() 与 signal() 方式LockSupport 方式 一. LockSupport 基础 LockSupport是什么: 是用来创建锁和其它同步类的基本线程阻塞原语,LockSupport中有两个方法park() 和unpark() park(): 阻塞线程 unpark(): 解除阻塞线程 简单来说: LockSupport 类,可以
深入剖析 ReentrantLock
weixin_46017166的博客
11-12 317
源码解析ReentrantLock
线程阻塞唤醒工具 ：LockSupport ，你知道吗
Java和Android架构
02-06 93
推荐阅读：一个人、一家公司、年入一个亿！网友：“程序员的梦想！”LockSupport 简介LockSupport是 Java 并发编程中一个非常重要的组件，我们熟知的并发组件Lock、线程池、CountDownLatch等都是基于AQS实现的，而AQS内部控制线程阻塞和唤醒又是通过LockSupport来实现的。从该类的注释上也可以发现，它是一个控制线程阻塞和唤醒的工具，与以往...
Java 上下文切换、用户态和内核态
zllovewln的专栏
06-03 1243
1、上下文切换 Thread.sleep() Object.wait() Thread.yield() Thread.join() LockSupport.park()
并发编程-05线程安全性之原子性【锁之synchronized】
小工匠
02-17 1万+
文章目录脑图概述原子性synchronized 修饰的4种对象修饰代码块作用范围及作用对象Demo多线程下 同一对象的调用多线程下不同对象的调用修饰方法作用范围及作用对象Demo多线程下同一个对象的调用多线程下不同对象的调用修饰静态方法作用范围及作用对象Demo多线程同一个对象的调用多线程下不同对象的调用修饰类作用范围及作用对象Demo多线程下同一对象的调用多线程下不同对象的调用使用Synchro...
面试官：谈谈你对并发编程下原子性操作的认识
12-21
文章目录引出问题（代码示例）问题原理说明问题解决方法1：使用锁机制方法2：原子类AtomicInteger原子类CAS机制实现线程安全概述源码分析CAS与Synchronized：乐观锁，悲观锁。 概述：所谓的原子性是指在一次操作或者...
并发编程基础知识，java内存模型及多线程、volatile
04-29
● volatile并不能真正的保证线程安全。它只能确保⼀个线程修改了数据后，其他线程能够看到这个改 动 当我们使⽤volatile去申明变量时，就等于告诉了虚拟机，这个变量极有可能会被某些程序或者线程 修改。为了确保这...
阿里专家级并发编程架构师课程-网盘链接提取码下载 .txt
02-19
课程内容包括了JAVA手写线程池，UC线程池API详解，线程安全根因详解，锁与原子类，分布式锁原理与实现方式，并发编程-AQS等等针对性非常强的JAVA编程开发教程，这其中的内容对JAVA开发技能的拔尖，非常的有帮助。...
查看对象大小
qq_35356190的博客
10-27 267
maven坐标 <dependency> <groupId>org.openjdk.jol</groupId> <artifactId>jol-core</artifactId> <version>0.10</version> </dependency> 代码 public stat...
Lock锁底层原理
热门推荐
Linias的博客
01-07 4万+
当多个线程需要访问某个公共资源的时候，我们知道需要通过加锁来保证资源的访问不会出问题。java提供了两种方式来加锁， 一种是关键字：synchronized，一种是concurrent包下的lock锁。 synchronized是java底层支持的，而concurrent包则是jdk实现。   关于synchronized的原理可以阅读再有人问你synchronized是什么，就把这篇文章...
LockSupport中的park与unpark原理
weixin_34077371的博客
12-02 1729
LockSupport是用来创建locks的基本线程阻塞基元，比如AQS中实现线程挂起的方法，就是park,对应唤醒就是unpark。JDK中有使用的如下 LockSupport提供的是一个许可，如果存在许可，线程在调用park的时候，会立马返回，此时许可也会被消费掉，如果没有许可，则会阻塞。调用unpark的时候，如果许可本身不可用，则会使得许可可用 许可只有一个，不可累加 park源码跟...
java环境部署
JiuMeilove的博客
06-04 407
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java中Overload和Override的区别
codedadi的博客
06-04 592
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 1441
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 648
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
拼图小游戏
lazy_girl_666的博客
06-03 725
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。
Java Map接口 - HashMap类
最新发布
IT深耕十余载，大道之简
06-05 172
当哈希表中的条目数超过容量与负载因子的乘积时，哈希表会重新调整大小（rehash）。是有序的或保证顺序的稳定性）。如果在迭代期间对映射进行了修改（结构修改，如添加或删除元素），则迭代可能会抛出。如果你打算在多线程环境中使用它，你需要额外的同步措施，或者可以考虑使用。不保证映射的顺序，特别是它不保证顺序会随着时间的推移而保持不变。操作（假设哈希函数是均匀的，并且表有足够的容量）。值（value）可以是重复的，并且可以为。提供了多种方法来遍历它的键、值或键值对，如。中，键（key）必须是唯一的，并且不能为。
shared_ptr的线程安全性
02-23
在多线程环境下，shared_ptr的线程安全性取决于两个方面：引用计数的原子操作和对象的访问控制。 首先，shared_ptr使用原子操作来更新引用计数。原子操作是不可中断的操作，可以保证在多线程环境下对引用计数的操作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值