JUC并发编程第九章——ThreadLocal

置顶 已于 2024-06-08 18:21:25 修改
阅读量1.3k 收藏 4
点赞数 39
分类专栏： JUC并发编程 文章标签： 面试 java 职场和发展
于 2024-06-05 23:17:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64064246/article/details/139484443
版权

1 ThreadLocal简介

1.1 面试题

  • ThreadLocal中ThreadLocalMap的数据结构和关系
  • ThreadLocal的key是弱引用，这是为什么？
  • ThreadLocal内存泄漏问题你知道吗？
  • ThreadLocal中最后为什么要加remove方法？

1.2 是什么？

        ThreadLocal提供线程局部变量。这些变量与正常的变量不同，因为每一个线程在访问ThreadLocal实例的时候（通过其get或set方法）都有自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态字段，使用它的目的是希望将状态（例如，用户ID或事物ID）与线程关联起来。

1.3 能干吗？

        实现每一个线程都有自己专属的本地变量副本（自己用自己的变量不用麻烦别人，不和其他人共享，人人有份，人各一份）。主要解决了让每个线程绑定自己的值，通过使用get()和set()方法，获取默认值或将其改为当前线程所存的副本的值从而避免了线程安全问题。比如8锁案例中，资源类是使用同一部手机，多个线程抢夺同一部手机，假如人手一份不是天下太平？

        所以ThreadLocal中存放的是属于自己线程中的一些属性，不用写回主物理内存的内容。

1.4 API介绍

initialValue()方法详细信息
protected T initialValue()

        返回此线程局部变量的当前线程的“初始值”。该方法将被调用的第一次一个线程访问与可变get()方法，除非线程先前调用的set(T)方法，在这种情况下initialValue方法将不被调用的线程。通常，每个线程最多调用一次此方法，但如果后续调用remove()后跟get()，则可以再次调用此方法。

        这个实现只返回null；如果程房员希望线程局部变量具有除null之外的初始值，ThreadLocal必须对ThreadLocal进行子类化，并且重写此方法。通常，将使用匿名内部类。

withInitial()方法详细信息
public static ThreadLocal withInitial(Supplier<? extends S> supplier)

创建一个线程局部变量，通过调用get上的Supplier方法确定变量的初始值

1.5 样例说明

需求

        5个销售卖房子，按照出单数各自统计。比如某房产中介销售都有自己的销售额指标，自己专属于自己的，不和别人掺和。

正好对应了前面的【每个线程都有自己专属的本地变量副本】

public class ThreadLocalDemo {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);

        House house = new House();
        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    //模拟当前线程从1-5中随机卖出的数量
                    int sale = new Random().nextInt(5) + 1;
                    for (int j = 0; j < sale; j++) {
                        house.saleVolumeByThreadLocal();
                    }
                    System.out.println(Thread.currentThread().getName() + "线程卖出了：" + house.saleVolume.get());
                } finally {
                    house.saleVolume.remove();
                    countDownLatch.countDown();
                }
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("总共卖出：" + house.saleCount);
    }
}

class House {
    //所有人卖出的总数
    AtomicInteger saleCount = new AtomicInteger();

    //每个线程的ThreadLocal初始化为0
    ThreadLocal<Integer> saleVolume = ThreadLocal.withInitial(() -> 0);

    public void saleVolumeByThreadLocal() {
        //获取对应线程的saleVolume再加1
        saleVolume.set(saleVolume.get() + 1);
        saleCount.getAndIncrement();
    }
}

5线程卖出了：2
1线程卖出了：5
2线程卖出了：2
3线程卖出了：2
4线程卖出了：2
总共卖出：13

注意，也要调用remove(） 接口，不然容易导致内存泄漏

        必须回收自定义的ThreadLocal变量，尤其在线程池场景下，线程经常会被复用，如果不清理自定义的ThreadLocal变量，可能会影像后序业务逻辑和造成内存泄露等问题。尽量在代理中使用try-finally块进行回收。

样例：

//Demo2-主要演示线程池情况下，线程池中的线程会复用(不会自动清空)，而上面的都是新建一个Thread
class MyData{
    ThreadLocal<Integer> threadLocalField = ThreadLocal.withInitial(() -> 0);
    public void add(){
        threadLocalField.set(1+ threadLocalField.get());
    }
}

/**
 * 根据阿里规范，需要对自定义的ThreadLocal进行回收，否则容易造成内存泄漏和业务逻辑问题(因为线程池中的线程会复用)
 */
public class ThreadLocalDemo2 {
    public static void main(String[] args) {
        MyData myData = new MyData();
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        try {
            for(int i = 0;i < 10;i ++){
                threadPool.submit(()->{
                    try {
                        Integer beforeInt = myData.threadLocalField.get();
                        myData.add();
                        Integer afterInt = myData.threadLocalField.get();
                        System.out.println(Thread.currentThread().getName()+"\t"+"beforeInt"+beforeInt+"\t afterInt"+afterInt);
                    } finally {
                        myData.threadLocalField.remove();
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}
//没有remove---出现了累积
//pool-1-thread-1  beforeInt0   afterInt1
//pool-1-thread-3  beforeInt0   afterInt1
//pool-1-thread-2  beforeInt0   afterInt1
//pool-1-thread-2  beforeInt1   afterInt2
//pool-1-thread-2  beforeInt2   afterInt3
//pool-1-thread-2  beforeInt3   afterInt4
//pool-1-thread-2  beforeInt4   afterInt5
//pool-1-thread-2  beforeInt5   afterInt6
//pool-1-thread-3  beforeInt1   afterInt2
//pool-1-thread-1  beforeInt1   afterInt2
//有remove-不会出现累积的情况
//pool-1-thread-1  beforeInt0   afterInt1
//pool-1-thread-3  beforeInt0   afterInt1
//pool-1-thread-2  beforeInt0   afterInt1
//pool-1-thread-1  beforeInt0   afterInt1
//pool-1-thread-3  beforeInt0   afterInt1
//pool-1-thread-1  beforeInt0   afterInt1
//pool-1-thread-2  beforeInt0   afterInt1
//pool-1-thread-1  beforeInt0   afterInt1
//pool-1-thread-3  beforeInt0   afterInt1
//pool-1-thread-2  beforeInt0   afterInt1

1.6 总结

  • 因为每个Thread内有自己的实例副本且该副本只有当前线程自己使用
  • 既然其他ThreadLocal不可访问，那就不存在多线程间共享问题
  • 统一设置初始值，但是每个线程对这个值得修改都是各自线程互相独立得
  • 如何才能不争抢
    • 加入synchronized或者Lock控制资源的访问顺序
    • 人手一份，大家各自安好，没有必要争抢

2 ThreadLocal源码分析

2.1 Thread、ThreadLocal、ThreadLocalMap关系

  • 根据官方API，Thread是程序中执行的线程；ThreadLocal类提供线程局部变量。

  • 先打开Thread.java类，发现每个Thread类里面有一个ThreadLocal类

  • 而ThreadLocalMap是ThreadLocal的一个静态内部类

  • 三者总概括

threadLocalMap实际上就是一个以threadLocal实例为key，任意对象为value的Entry对象。
当我们为threadLocal变量赋值，实际上就是以当前threadLocal实例为key，值为value的Entry往这个threadLocalMap中存放

举个例子：每个Thread就相当于一个自然人，而ThreadLocal对应的是身份证，每个人 (Thread) 都有着和他唯一对应的身份证 (ThreadLocal) 。而身份证上有很多信息，比如说姓名、出生日期、家庭地址等等。对应的就是ThreadLocalMap

2.2 小总结

近似可以理解为:
ThreadLocalMap从字面上就可以看出这是一个保存ThreadLocal对象的map(其实是以ThreadLocal为Key)，不过是经过了两层包装的ThreadLocal对象：（两层包装可以看下面的解释）

        JVM内部维护了一个线程版的Map<Thread,T>(通过ThreadLocal对象的set方法，结果把ThreadLocal对象自己当做key，放进了ThreadLoalMap中,每个线程要用到这个T的时候，用当前的线程去Map里面获取，通过这样让每个线程都拥有了自己独立的变量，人手一份，竞争条件被彻底消除，在并发模式下是绝对安全的变量。

3 ThreadLocal内存泄漏问题

3.1 从阿里开发手册和面试题开始讲起

  1. 如果不清理自定义的 ThreadLocal 变量，可能会影响后续业务逻辑和造成内存泄露等问题，什么是内存泄露？为什么会导致内存泄露？
  2. static class Entry extends WeakReference<ThreadLocal<?>>为什么ThreadLocalMap类的静态内部类Entry要继承弱引用类？不继承弱引用类会怎么样？

3.2 什么是内存泄漏

不再会被使用的对象或者变量占用的内存不能被回收，就是内存泄漏

3.3 谁惹的祸？

  • 再回首ThreadLocalMap

ThreadLocalMap从字面上就可以看出这是一个保存ThreadlLocal对象的map(以ThreadLocal为Key，不过是经过了两层包装的 ThreadLocal对象：
（1）第一层包装是使用 WeakReference<ThreadLocal<?>> 将ThreadLocal对象变成一个弱引用的对象。
（2）第二层包装是定义了一个专门的类 Entry 来扩展 WeakReference<ThreadLocal<?>>。

3.2 强引用，软引用，弱引用分别是什么？

3.2.1 整体架构

Java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。

官方API:finalize()的通常目的是在对象被不可撤销地丢弃之前执行清理操作。

(某个对象被干掉前还会调用finalize()，但只会调用一次，若在finalize恢复引用了，泽本次垃圾回收不回收它，但下一次就会直接跳过finalize方法，直接把该对象回收了）

Reference是强引用

SoftReference是软引用

WeakReference是弱引用

PhantomReference是虚引用

新建一个待finalize()方法的对象MyObject用作以下四个引用举例使用

class MyObject{
    @Override
    protected void finalize() throws Throwable{
        //finalize的通常目的是在对象被不可撤销的丢弃之前进行清理操作
        System.out.println("finalize()被调用-------invoke finalize");
    }
}

3.2.2 强引用（默认支持模式）

  • 当内存不足，JVM开始垃圾回收，对于强引用的对象，就算是出现了OOM也不会对该对象进行回收，死都不收。
  • 强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰这种对象。在 Java 中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到JVM也不会回收。因此强引用是造成Java内存泄漏的主要原因之一。
  • 对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为 null，一般认为就是可以被垃圾收集的了(当然具体回收时机还是要看垃圾收集策略)。
public class referenceDemo {
    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        System.out.println("gc before"+myObject);

        myObject = null;//new 一个对象是一个强引用，如果不把他指为null，垃圾回收回收不了他
        System.gc();//人工开启gc 一般不用

        System.out.println("gc after "+myObject);
    }
}
//gc beforecom.zhang.admin.controller.MyObject@2f4d3709
//gc after null
//finalize()被调用-------invoke finalize      -------这不就是在对象丢弃之前进行一个清理操作，这里确实清理了

3.2.3 软引用

软引用是一种相对强引用弱化了一些的引用，需要用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集

对于只有软引用的对象而言，当系统内存充足时，不会被回收，当系统内存不足时，他会被回收

软引用通常用在对内存敏感的程序中，比如高速缓存，内存够用就保留，不够用就回收。

先配置一下jvm内存大小为10mb

public class referenceDemo {
    public static void main(String[] args) {
        SoftReference<MyObject> softReference = new SoftReference<>(new MyObject());
        System.gc();
        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-------gc after内存够用"+softReference.get());

        try {
            byte[] bytes = new byte[20 * 1024 * 1024];
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("---------gc after内存不够"+softReference.get());
        }
    }
}
//-------gc after内存够用com.zhang.admin.controller.MyObject@2f4d3709
//---------gc after内存不够null，（因为是软引用，在内存不足时被清理了）
//finalize()被调用-------invoke finalize
//Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
//  at com.zhang.admin.controller.referenceDemo.main(referenceDemo.java:22)

        这里可以看到：内存大小一共只有10mb，但我们创建了一共20mb的对象，就会把先前创建的软引用对象给自动垃圾回收。

3.2.4 弱引用

弱引用需要用java.lang.ref.WeakReference类来实现，它比软引用的生存期更短，

对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管JVM的内存空间是否足够，都会回收该对象占用的内存。

public class referenceDemo {
    public static void main(String[] args) {
        WeakReference<MyObject> weakReference = new WeakReference<>(new MyObject());
        System.out.println("-----gc before 内存够用 "+ weakReference.get());

        System.gc();
        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
        //暂停几秒钟线程
        System.out.println("----gc after内存够用 "+weakReference.get());
    }
}
//-----gc before 内存够用 com.zhang.admin.controller.MyObject@2f4d3709
//finalize()被调用-------invoke finalize
//----gc after内存够用 null ------- (不管怎么样都会清楚，这即是弱引用)

        适用场景
假如有一个应用需要读取大量的本地图片:

  • 如果每次读取图片都从硬盘读取则会严重影响性能,
  • 如果一次性全部加载到内存中又可能造成内存溢出。

此时使用软引用可以解决这个问题。

        设计思路是：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。

3.2.5 虚引用

  • 定义

        1.虚引用必须和引用队列 (ReferenceQueue)联合使用
虚引用需要java.lang.ret.PhantomReterence类来实现,顾名思义， 就是形同虚设**，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有院引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，它不能单独使用也不能通过它访问对象，虚引用必须和引用队列(ReferenceQueue)联合使用。

        2.PhantomReference的get方法总是返回null
虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一和确保对象被 finalize以后，做某些事情的通知机制。
PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。

        3.处理监控通知使用
换句话说，设置虚引用关联对象的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理，用来实现比finalize机制更灵活的回收操作。

  • 构造方法

在这里插入图片描述

  • 引用队列

我被回收前需要被引用队列保存下

记得先给设置成-Xms10m -Xmx10m

class MyObject{
    @Override
    protected void finalize() throws Throwable{
        //finalize的通常目的是在对象被不可撤销的丢弃之前进行清理操作
        System.out.println("finalize()被调用-------invoke finalize");
    }
}

public class referenceDemo {
    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        ReferenceQueue<MyObject> referenceQueue = new ReferenceQueue<>();
        PhantomReference<MyObject> phantomReference = new PhantomReference<>(myObject, referenceQueue);
       // System.out.println(phantomReference.get());//这里就是个null--虚引用的get()就是null

        List<byte[]> list = new ArrayList<>();

        new Thread(() -> {
            while (true)//模拟一个无限循环
            {
                list.add(new byte[1 * 1024 * 1024]);
                try { TimeUnit.MILLISECONDS.sleep(600); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println(phantomReference.get());
            }
        },"t1").start();

        new Thread(() -> {
            while (true)
            {
                Reference<? extends MyObject> reference = referenceQueue.poll();
                if (reference != null) {
                    System.out.println("有虚对象加入队列了");
                }
            }
        },"t2").start();

    }
}
//null
//finalize()被调用-------invoke finalize
//null
//null
//null
//null
//null
//有虚对象加入队列了  ------(说明被干掉之后进入了这个引用队列)
//Exception in thread "t1" java.lang.OutOfMemoryError: Java heap space
//  at com.zhang.admin.controller.referenceDemo.lambda$main$0(referenceDemo.java:30)
//  at com.zhang.admin.controller.referenceDemo$$Lambda$1/1108411398.run(Unknown Source)
//  at java.lang.Thread.run(Thread.java:748)

3.2.6 GCRoots和四大引用小总结

3.3 Thread、ThreadLocal、ThreadLocalMap关系大总结

​

        ThreadLocal只是一个壳子，真正的存储结构是ThreadLocal里的ThreadLocalMap内部类，每个Thread对象维护着一个ThreadLocalMap的引用。
        ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储。
1.调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，值Value是传递进来的对象。
2.调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，key是ThreadLocal对象。
        ThreadLocal本身并不存储值，它只是自己作为一个key来让线程从ThreadLocalMap获取value，正因为这个原理，所以ThreadLocal能够实现“数据隔离”，获取当前线程的局部变量值，不受其他线程影响。

3.4 为什么要用弱引用？不用如何？

为什么源码要用弱引用？
当function01方法执行完毕后，栈帧销毁，强引用tl也就没有了，但此时线程的ThreadLocalMap里某个entry的key引用还指向这个对象（因为即使执行function01方法的线程销毁了，ThreadLocal是另一个类，是两个不同的类，具有独立性）

举个例子：之前也说了这两个类之间的关系就像自然人 (Thread) 和 身份证 (ThreadLocal) 一样，人是人，身份证是身份证，是两样不同的东西。如果这个人去世了，这个身份证也应该作废销毁。一句话，身份证应该跟着人走。如果是强引用，就会出现人没了，但身份证信息还存在，这样信息就会越来越多导致内存溢出。

若这个Key是强引用，就会导致Key指向的ThreadLocal对象即V指向的对象不能被gc回收，造成内存泄露。

若这个引用时弱引用就大概率会减少内存泄漏的问题（当然，还得考虑key为null这个坑），使用弱引用就可以使ThreadLocal对象在方法执行完毕后顺利被回收且entry的key引用指向为null。

弱引用就万事大吉了吗？
使用弱引用就可以使ThreadLocal对象在方法执行完毕后顺利被回收且entry的key引用指向为null。此后我们调用get、set或remove方法时，就会尝试删除key为null的entry，可以释放value对象所占用的内存

key为null的情况：

        1.当我们为threadLocal变量赋值，实际上就是当前的Entry(threadLocal实例为key，值为value)往这个threadLocalMap中存放。Entry中的key是弱引用，当threadLocal外部强引用被置为null (如 t1 = null ) ，那么系统 GC 的时候，根据可达性分析，这个threadLocal实例就没有任何一条链路能够引用到它，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话（这个t1就不会被干掉），这些key为null的Entry的value就会一直存在一条强引用链：Thread的引用 -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

        2.当然，如果当前thread运行结束，threadLocal，threadLocalMap,Entry没有引用链可达，在垃圾回收的时候都会被系统进行回收。

        3.但在实际使用中我们有时候会用线程池去维护我们的线程，比如在Executors.newFixedThreadPool()时创建线程的时候，为了复用线程是不会结束的，所以threadLocal内存泄漏就值得我们小心。

总结：我们知道，一个Thread对应一个ThreadLocalMap，但可以在一个线程下创建多个ThreadLocal对象，每个ThreadLocal对象都可以作为ThreadLocalMap中的key。这时候，如果多个ThreadLocal对象使用完毕外部强引用赋值为null希望被垃圾回收 (new一个ThreadLocal对象的时候就是强引用，只是在ThreadLocalMap中的key是弱引用) 。这时候就出现了key为null但value还存在着的情况。如果这时候由于线程复用，Thread迟迟不结束，就会可能会导致越来越多的key为null (比如说现在ThreadLocalMap中有十个键值对，key从t1到t10，但这些ThreadLocal对象其实都已经被销毁了全部为null，下一次线程池复用该线程，这十个key对应的value是无法被内存释放的)

解决方法：set、get方法会去检查所有键为null的Entry对象

这些方法都对key== null 也就是脏Entry进行了处理，防止内存泄漏

  • set() 方法

  • get()方法

  • remove()方法

简而言之，如果一个ThreadLocal调用以上三种方法，都会在底层做个检查。如果当前ThreadLocal已经为null，就会去ThreadLocalMap中把对应的value赋值为null，等垃圾回收的时候就会自动释放内存了。

3.5 ThreadLocal使用建议

1.使用ThreadLocal一定要初始化，避免空指针异常

  • 使用ThreadLocal.withInitial(() -> 初始化值);方式初始化即可

2.建议把ThreadLocal修饰为static

阿里开发手册：

  • 【参考】ThreadLocal 对象使用 static 修饰，ThreadLocal 无法解决共享对象的更新问题。
  • 说明：这个变量是针对一个线程内所有操作共享的，所以设置为静态变量，所有此类实例共享此静态变量也就是说在类第一次被使用时装载，只分配一块存储空间，所有此类的对象（只要是这个线程内定义的）都可以操控这个变量。
  • 个人解释：ThreadLocal实现了线程的数据隔离，不在于它自己本身，而在于Thread的ThreadLocalMap，所以ThreadLocal可以只初始化一次，只分配一块存储空间就足以，没必要作为成员变量多次被初始化

3.用完一定记得手动remove

  • remove()方法不仅会清理当前ThreadLocal对象，还会通过expungeStaleEntry()方法清理掉key为null的脏Entry

4 总结

  1. ThreadLocal并不解决线程间共享数据的问题
  2. ThreadLocal适用于变量在线程间隔离且在方法间共享的场景
  3. ThreadLocal通过隐式的在不同线程内创建独立实例副本避免了实例线程安全的问题
  4. 每个线程持有一个只属于它自己的专属map并维护了ThreadLocal对象与具体实例的映射，该Map由于只被持有他的线程访问，故不存在线程安全以及锁的问题
  5. ThreadLocalMap的Entry对ThreadLocal的引用为弱引用。避免了ThreadLocal对象无法被回收的问题
  6. 都会通过expungeStaleEntry，cleanSomeSlots，replaceStaleEntry这三个方法回收键为null的Entry对象的值（即为具体实例）以及entry对象本身从而防止内存泄漏，属于安全加固的方法
  7. 群雄逐鹿起纷争，人手一份天下安

一只特立独行的猪611
关注
  • 39
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bilibili尚硅谷周阳老师JUC并发编程与源码分析课程笔记第九章——聊聊ThreadLocal
qq_46601365的博客
02-22 935
ThreadLocal中ThreadLocalMap的数据结构和关系？ThreadLocal的key是弱引用，这是为什么？ThreadLocal内存泄漏问题你知道吗？ThreadLocal中最后为什么要加remove方法？返回此线程局部变量的当前线程的“初始值”。该方法将被调用的第一次一个线程访问与可变get()方法，除非线程先前调用的set(T)方法，在这种情况下initialValue方法将不被调用的线程。
JUC并发编程面试题
weixin_45081813的博客
04-06 2519
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
JUC并发编程最新面试题（持续更新）
个人笔记git：https://gitee.com/tlangp/note.git
02-23 993
多线程：多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务。多线程的好处： 可以提高 CPU 的利用率。在多线程程序中，一个线程必须等待的时候，CPU 可以运行其它的线程而不是等待，这样就大大提高了程序的效率。也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；多线程需要协调和管理，所以需要 CPU 时间跟踪线程；线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问 题。
JUC 并发编程
weixin_49561445的博客
10-04 443
1 什么是 JUC java.util.concurrent 并发工具包 用来优雅的解决多线程下的高并发问题，JUC 下的大部分类均由Doug Lea 设计开发，此乃神人也！ 让 Java 程序员膜拜的大神，这个憨态可掬的老者让人又爱又恨！ JUC 的基本框架 2 线程与进程 概念 进程：一个程序，或者程序的集合 一个进程可以包含多个线程，至少包含一个java默认有2个线程 mian GC 线程：进程下的不同操作有线程操作负责的 Thread Runnable Callable java 无法直接
JUC并发编程详解
cqdddgs的博客
08-03 303
completion stage:代表异步计算过程中的某个阶段一个阶段完成以后可能会触发另一个阶段在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组completableFuture 的方法。它可能代表一个明确完成的Future，也有可能代表一个完成阶段〈CompletionStage )，它支持在计算完成以后触发一些函数或执行某些动作。
【Java 】JUC并发编程
秋刀鱼与猫的博客
02-03 1573
Java 并发 引入 1、程序、进程、线程的概念 程序 ​ 通常为了完成特定的任务、用某种语言编写的一组指令的结合。即一段静态的代码 进程 ​ 程序的一次执行，或者是正在运行的一段程序，是一个动态过程，有自身的生命周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程 ​ 进程可进一步细化为线程，是一个程序内部的一条执行路径 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc
尚硅谷JUC并发编程课程笔记总结
qq_59366033的博客
08-20 1399
JUC并发编程 1、什么是juc JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！ 2、线程基础知识复习 1把锁：synchronized（后面细讲） 2个并： 并发：（concurrent）：是在同一实体上的多个事件，是在一台机器上“同时”处理多个任务，同一时刻，其实是只有一个事情再发生。 并行（parallel）：是在不同实体上的多个事件，是在多台处理器上同时处理多个任务，
JUC并发编程（高级）
weixin_47171905的博客
03-28 282
异步任务结束时，会自动回调某个对象的方法；主线程设置好毁掉后，不再关心异步任务的执行，异步任务之间可以顺序执行异步任务出错时，会自动回调某个对象的方法。StampedLock的特点所有获取锁的方法，都返回一个邮戳( Stamp) , Stamp为零表示获取失败，其余都表示成功;所有释放锁的方法，都需要一个邮戳(Stamp)，这个Stamp必须是和成功获取锁时得到的Stamp一致;StampedLock是不可重入的，危险(如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁)
JUC并发编程
weixin_46375204的博客
10-24 47
Future异步接口（FutureTask实现类）定义了操作异步任务执行一些方法，如获取异步任务的执行结果、取消异步任务的执行、判断任务是否被取消、判断任务执行是否完毕等。FutureTask实现了Future 和 Runnable 接口，可以创建线程和操作线程，但是没有返回值。同时重写run方法去执行Callable 的call方法，FutureTask 将 Callable 构造注入。重写Future 接口的get方法获取返回值。
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
JUC并发编程.rar
12-14
"JUC并发编程.rar"这个压缩包文件包含了关于并发编程的相关案例源码和详细讲解，旨在帮助初学者和经验丰富的开发者深入理解并发编程的核心概念和技术。 首先，让我们来看看并发编程的基本概念。并发是指在一段时间...
2024年C++面试题汇总及答案解析
soaring_casia的专栏
07-25 536
唯一的指针，不允许其他指针与他共享指向的对象。比如指针指向的内存被释放了，但是指针没有置nullptr. 多个指针指向同一个内存，当free掉一个指针之后，其他指针就变成了野指针。C++这些年虽然难度大，但是热度仍然不减，在编程排行榜基本上都是前几位，得益于它良好的薪资待遇。SPI协议是一种采用主从模式的串行，全双工，同步通信总线，包括时钟，输入，输出，片选四个信号线，片选信号用于选择slave设备，输入输出的每个bit都需要和时钟沿同步。区别：指针指向一块儿内存，他的内容是所指内存的地址。
（面试必看！）一些和多线程相关的面试考点
最新发布
2302_78814792的博客
07-28 771
本篇文章总结了多线程中面试频率比较高的考点，内容可能比较琐碎，但是如果能够坚持看完，注意总结积累，相信对面试会有很大帮助。多线程内容较多，用一篇文章写完可能篇幅过长，我打算用两篇文章来总结，本篇主要写的是多线程中辅助加锁的数据结构和指令，下一篇主要讲的是锁策略。
规控面试常见问题
每天进步一点点。
07-28 62
（1）A*在节点的扩张时，只会进行相邻节点的直线移动，没有考虑实际底盘的运动学模型（物理模型），而Hybrid A*在每次节点扩张的时候，会对下个位置进行离散状态空间的采样（比如 旋转角度、前进距离、前进/后退），选择动作之后就可以根据运动学模型计算下一个位置点的位姿，每次扩展的时候选择代价最小的节点进行扩展就能逐步到到目标点。// 8领域的坐标x y 和 g。A*受限于邻近栅格之间的连线，A*在搜索过程中扩展节点的方向被网格形状固定，一般为8邻接，导致路径呈波浪状，不平滑，发生抖动，冗余节点过多。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值