Java问题学习（一）- JUC

最新推荐文章于 2024-07-28 19:41:52 发布
最新推荐文章于 2024-07-28 19:41:52 发布
阅读量42 收藏
点赞数
分类专栏： Java学习记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yongmingyongye/article/details/117283839
版权

JUC

1、volatile

1.1、谈谈对volatile的理解

（1）volatile是java虚拟机提供的轻量级的同步机制

  1. 保证可见性
  2. 不保证原子性
  3. 禁止指令重排

（2）谈谈JMM

JMM（Java内存模型Java Memory Model，简称JMM）本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素） 的访问方式。

JMM关于同步的规定：

  1. 线程解锁前，必须把共享变量的值刷新回主内存
  2. 线程加锁前，必须读取主内存的最新值到自己的工作内存
  3. 加锁解锁是同一把锁

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成，其简要访问过程如下图：

三大特性：

  1. 可见性
  2. 原子性
  3. 有序性 

VolatileDemo代码演示可见性： 

class MyData {
    int number = 0;
    public void add() {
        this.number = 60;
    }
}
/**
 * 验证volatile的可见性
 */
public class VolatileDemo {
    public static void main(String[] args) {
        // 线程要操作的资源类
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\tcome in");
            // 暂停一会儿
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 修改值
            myData.add();
            System.out.println(Thread.currentThread().getName() + "\tupdate number value: " + myData.number);
        }, "线程A").start();
        // 第二个线程为main线程
        while (myData.number == 0) {
            // main线程一致循环，直到number值不再等于0
        }
        System.out.println(Thread.currentThread().getName() + "\tmission is over");
    }
}

 上述代码一直会卡死，不会结束运行，这里的number没有修改。加上volatile：volatile int number = 0; 代码可以正常运行

VolatileDemo代码演示不保证原子性

class MyData {
    volatile int number = 0;
    void add() {
        this.number = 60;
    }
    /**
     * 请注意，此时已经添加了volatile关键字
     */
    void addPlusPlus() {
        number++;
    }
}
/**
 * 验证volatile的可见性
 * 1、添加了volatile，可以解决可见性问题
 * 2、验证volatile不保证原子性
 *     原子性指：不可分割，完整性，即某个线程正在做某个具体业务时，中途不可被分割或抢占。业务要么都成功、要么都失败
 *
 * @author fx
 */
public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        int n = 20;
        for (int i = 1; i <= n; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    try {
                        // 延时一下，保证效果展现
                        TimeUnit.MILLISECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    myData.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }
        // 等待上面20个线程全部计算完成后，再用main取得最终的结果
        // 后台默认至少有两个线程：mian与gc线程
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "\t number :" + myData.number);

    }
}

 执行上述代码：发现其结果并不是 20 * 1000 = 20000，一般情况下比这个值小，如果相等请将循环次数变大或者延时时间加长。

volatile不具备原子性分析：

如何解决原子性问题：

class MyData {
    volatile int number = 0;

        void add() {
        this.number = 60;
    }
    /**
     * 请注意，此时已经添加了volatile关键字，但不保证原子性
     */
    void addPlusPlus() {
        number++;
    }

    /**
     * 默认为0
     */
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addAtomic() {
        // 自增1
        atomicInteger.getAndIncrement();
    }
}
/**
 * 验证volatile的可见性
 * 1、添加了volatile，可以解决可见性问题
 * 2、验证volatile不保证原子性
 *     原子性指：不可分割，完整性，即某个线程正在做某个具体业务时，中途不可被分割或抢占。业务要么都成功、要么都失败
 *
 * @author fx
 */
public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        int n = 20;
        for (int i = 1; i <= n; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    try {
                        // 延时一下，保证效果展现
                        TimeUnit.MILLISECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    myData.addPlusPlus();
                    myData.addAtomic();
                }
            }, String.valueOf(i)).start();
        }
        // 等待上面20个线程全部计算完成后，再用main取得最终的结果
        // 后台默认至少有两个线程：mian与gc线程
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "\t number :" + myData.number);
        System.out.println(Thread.currentThread().getName() + "\t atomic :" + myData.atomicInteger);

    }    
}

输出结果：

main     number :19981
main     atomic :20000

 1.2、volatile指令重排

计算机在执行程序时，为了提高性能，编译器和处理器的常常会对指令做重排，一般分以下3种：

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。

处理器在进行重排序时必须要考虑指令之间的数据依赖性

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测 

volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象

先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：

  1. 保证特定操作的执行顺序
  2. 保证某些变量的内存可见性（利用改特性实现volatile的内存可见性） 

由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。内存屏障另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

1.3 线程安全性获得保证

工作内存与主内存同步延迟现象导致的可见性问题：

可以使用synchronized或volatile关键字解决，它们都可以使一个线程修改后的变量立即对其他线程可见。

对于指令重排导致的可见性问题和有序性问题，可以利用volatile关键字解决，因为volatile的另一个作用就是禁止重排序优化。

2、单例模式

DCL机制下的单例代码：

public class SingletonDemo {
    private static SingletonDemo instance = null;
    private SingletonDemo() {
        System.out.println(Thread.currentThread().getName() + "\t我是构造方法");
    }
    /**
     * DCL (Double Check Lock 双端检锁机制)
     * @return 返回单例
     */
    public static SingletonDemo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo.class) {
                if (instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        int n = 10;
        for (int i = 1; i <= n; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

 分析：

DCL机制不一定线程安全，原因是有指令重排的存在，加入volatile可以禁止指令重排。

原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。

instance = new SingletonDemo(); 可以分为以下3步完成（伪代码）

memory = allocate(); // 1、分配对象内存空间

instance(memory); // 2、初始化对象

instance = memory; // 3、设置instance指向刚分配的内存地址，此时instance != null

步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。 

instance = new SingletonDemo(); 可以分为以下3步完成（伪代码）

memory = allocate(); // 1、分配对象内存空间

instance = memory; // 3、设置instance指向刚分配的内存地址，此时instance != null，但是对象还没有初始化完成！

instance(memory); // 2、初始化对象

但是指令重排只会保证串行语义的执行的一致性（单线程），但并不会关心多线程间的语义一致性。

所有当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。

3、CAS

3.1、CAS是什么？

比较并交换。

（1）底层原理

atomicInteger.getAndIncrement()：unsafe.getAndAddInt(0, 1) // 自增1

（2）Unsafe

是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。

注意：Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。

变量valueOffset，表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。

变量value用volatile修饰，保证了多线程之间的内存可见性。

CAS全程为Compare-And-Swap，它是一条CPU并发原语。它的功能时判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用Unsafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

 

Unsafe类中的compareAndSwapInt，是一个本地方法，该方法的实现位于unsafe.cpp中

3.2 CAS的缺点

（1）循环时间长，开销大

如果CAS失败，会一直进行操作。如果长时间一直不成功，可能会给CPU带来很大的开销。

（2）只能保证一个共享变量的原子操作

对于多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。

（3）ABA问题

CAS算法实现一个重要前提需要取出内存中某一时刻的数据并在当下时刻比较并替换，那么这个时间差可能会导致数据的变化。

比如一个线程one从内存位置V中取出A，这时另一个线程two也从内存中取出A，并且线程tow进行一些操作将值变成了B，然后线程two又将V位置的数据变成了A，这时线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功。

尽管线程one的CAS操作成功了，但不代表这个过程是没问题的。

1）原子引用

@Data
@ToString
@AllArgsConstructor
class User {
    String userName;
    int age;
}

public class AtomicReferenceDemo {
    public static void main(String[] args) {
        User z3 = new User("z3", 22);
        User li4 = new User("li4", 23);
        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(z3);

        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
    }
}

 2）ABA问题解决

public class ABADemo {

    /**
     * 普通原子引用
     */
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    /**
     * 带戳的原子引用
     */
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);
    public static void main(String[] args) {
        System.out.println("=====================以下产生ABA问题==========================");
        new Thread(() -> {
            atomicReference.compareAndSet(100, 101);
            atomicReference.compareAndSet(101, 100);
        }, "t1").start();

        new Thread(() -> {
            // 暂停1s，保证t1线程完成一次ABA操作
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 121) + "\t" + atomicReference.get());
        }, "t2").start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("=====================以下解决ABA问题==========================");
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t第2次版本号：" + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t第3次版本号：" + atomicStampedReference.getStamp());

        }, "t3").start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
            atomicStampedReference.compareAndSet(100, 111, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\t当前最新值：" + atomicStampedReference.getReference());

        }, "t4").start();
    }
}

注：其中原子引用代码只是用来演示ABA问题，这里面Integer会有自动包装机制问题，AtomicReference比较的是引用的地址，Integer中128以内的会使用缓存，超了就不是一个对象了，就会返回false导致无法交换值。

4、集合类之不安全

4.1 并发修改异常

案例代码：

public class ContainerNotSafeDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 60; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i + 1)).start();
        }
    }
}

 （1）故障现象

Exception in thread "58" java.util.ConcurrentModificationException

（2）导致原因

并发争抢修改，参考例子花名册签名情况。一个人正在写入，另外一个同学过来直接抢。

（3）解决方案

方案一：

List<String> list = Collections.synchronizedList(new ArrayList<>());

方案二：

List<String> list = new CopyOnWriteArrayList<>();

写时复制：

CopyOnWrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器Object[] 添加，而是先将当前Object[]进行Copy，复制出一个新的容器Objectp[] newElements，然后新的容器Object[] newElements里添加元素，添加完元素之后，再将原容器的引用指向新的容器setArray(newElements)；这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所有copyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

 4.2 Set

Set<String> set = new CopyOnWriteArraySet<>();

CopyOnWriteArraySet实际底层还是一个 CopyOnWriteArrayList

4.3 Map

Map<String, String> map = new ConcurrentHashMap<>();
public V put(K key, V value) {
        return putVal(key, value, false);
    }

    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

 

yongmingyongye
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【java】java的unsafe
九师兄
05-15 1273
1.概述 转载：https://leokongwq.github.io/2016/12/31/java-magic-unsafe.html Java是一个安全的编程语言，它能最大程度的防止程序员犯一些低级的错误（大部分是和内存管理有关的）。但凡是不是绝对的，使用Unsafe程序员就可以操作内存，因此可能带来一个安全隐患。 这篇文章是就快速学习下sun.misc.Unsafe的公共API和一些有趣的使用例子。 2.Unsafe 实例化 在使用Unsafe之前我们需要先实例化它。但我们不能通过像Unsafe .
个人学习-JUC-笔记
02-25
本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人学习者深入理解和掌握Java并发编程的核心知识。 1. **并发基础** - **线程与进程**：线程是程序执行的最小单位，进程则是资源分配的基本单位。了解它们的...
【面试题】为什么需要 public static void main (String[ ] args) 这个方法？
风信子
05-27 3284
public static void main (String [ ] args) 为Java程序的入口方法，JVM在运行程序时，会首先查找 main() 方法。其中，public 是权限修饰符，表明任何类或对象都可以访问这个方法，static 表明 main() 方法是一个静态方法，即方法中的代码是存储在静态存储区，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过类名....
JAVA错误: 在类中找不到主方法, 请将主方法定义为:public static void main(String[] args)
tus00000的博客
02-17 8968
一个类只有包含了入口才能运行，这个入口告诉了系统从哪开始运行程序，入口的格式为： public static void main(String[] args)
jvm-juc：jvm学习笔记
03-03
Java虚拟机（JVM）是Java程序运行的核心，它为Java应用程序提供了一个跨平台的运行环境。JVM通过解释执行字节码（.class文件）来实现Java的“一次编写，到处运行”特性。JVM的主要组件包括类装载器、运行时数据区、...
tuling-juc-final.zip
05-23
本项目"tuling-juc-final.zip"显然聚焦于Java并发编程的实践，通过一系列代码示例来演示和解释Java内存模型（JMM）、`synchronized`关键字以及`volatile`关键字的使用。下面我们将深入探讨这些核心概念。 Java内存...
heima-JUC-资料
04-25
在Java中，JUC包（java.util.concurrent）包含了一系列的类和接口，这些类和接口主要用于解决并发问题，如线程池、同步容器、并发集合、锁、原子变量等。下面我们将深入探讨这些关键概念： 1. **线程池**：Java通过...
golang 接口
m0_70982551的博客
07-24 952
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 516
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 646
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 595
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 367
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 428
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 861
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 101
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 187
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 273
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
Java-JUC-多线程进阶是一门关于Java并发编程的课程，来源于B站的《遇见狂神说》。这门课程于2019年5月31日发布，主要涵盖了以下主题：JUC的概念，进程和线程的回顾，Lock锁的使用，生产者和消费者模式，8锁的现象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值