JUC ThreadLocal

已于 2024-02-07 08:44:45 修改
阅读量1k 收藏 25
点赞数 13
分类专栏： 人在江湖之J.U.C 详解 文章标签： ThreadLocal ThreadLocal源码分析 内存泄漏问题
于 2024-02-07 08:39:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/forlinkext/article/details/135166506
版权

文章目录

ThreadLocal 1.2 的作用

ThreadLocal 为每个线程提供单独的变量副本。每个变量副本都是线程私有的，线程之间互不影响。当线程执行完成后，对应的变量副本也会被垃圾回收。

在线程中通过 ThreadLocal 的 get、set 方法获取或设置变量的值

使用场景

  1. 每个线程需要有自己单独的变量
  2. 变量需要在多个方法中共享，但不希望被多线程共享

示例1

还是用我们的 Car 对象来说明，比如同一个品牌同一个型号的汽车，可能只有颜色不一样，这时我们就可以使用 ThreadLocal 来定义颜色字段，使他在不同的线程中有不同的副本

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ThreadLocalTest1 {

    public static void main(String[] args) {
        // 线程间共享的对象
        Car car = new Car();

        new Thread(()->{

            car.setSkeleton("骨架1");
            car.setEngine("引擎1");
            car.setTire("轮胎1");
            car.setColor("颜色1");

            log.debug("{}",car);

        },"t1").start();

        new Thread(()->{

            car.setSkeleton("骨架2");
            car.setEngine("引擎2");
            car.setTire("轮胎2");
            car.setColor("颜色2");

            log.debug("{}",car);

        },"t2").start();

        new Thread(()->{

            car.setSkeleton("骨架3");
            car.setEngine("引擎3");
            car.setTire("轮胎3");
            car.setColor("颜色3");

            log.debug("{}",car);

        },"t3").start();

    }

    @Slf4j
    @Getter
    @Setter
    @ToString
    static class Car{

        /**
         * 骨架
         */
        private String skeleton;

        /**
         * 发动机
         */
        private String engine;

        /**
         * 轮胎
         */
        private String tire;

        /**
         * 颜色
         */
        private ThreadLocal<String> color = new ThreadLocal<>();

        public void setColor(String color) {
            this.color.set(color);
        }

        public String getColor() {
            return this.color.get();
        }
    }

}

执行结果：

12:01:14.655 [t1] DEBUG com.yyoo.thread.ThreadLocalTest1 - ThreadLocalTest1.Car(skeleton=骨架3, engine=引擎3, tire=轮胎3, color=颜色1)
12:01:14.655 [t2] DEBUG com.yyoo.thread.ThreadLocalTest1 - ThreadLocalTest1.Car(skeleton=骨架3, engine=引擎3, tire=轮胎3, color=颜色2)
12:01:14.655 [t3] DEBUG com.yyoo.thread.ThreadLocalTest1 - ThreadLocalTest1.Car(skeleton=骨架3, engine=引擎3, tire=轮胎3, color=颜色3)

通过结果可以发现，没有使用 ThreadLocal 的字段每个线程是共享使用的，但color 字段是每个线程独有的

注：这里我们还是使用的 new Thread ，而没有使用线程池，因为使用线程池有一个问题，我们下面再说。

ThreadLocal 变量初始化

我们上面的示例，直接使用的 new ThreadLocal<>()，其初始化的值为：null。有些时候我们需要初始化为其他值

  1. 用 set 方法直接设置
  2. 继承 ThreadLocal ，重写 protected T initialValue() 方法

在第一次调用 get 方法时，会调用此方法返回初始值。（前提是没有调用 set 方法）

  1. 调用 ThreadLocal 的静态方法 withInitial(Supplier<? extends S> supplier)

该方法返回一个 ThreadLocal 的静态内部类 SuppliedThreadLocal，其最终方式就是继承 ThreadLocal ，重写 initialValue 方法。

    static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {

        private final Supplier<? extends T> supplier;

        SuppliedThreadLocal(Supplier<? extends T> supplier) {
            this.supplier = Objects.requireNonNull(supplier);
        }

        @Override
        protected T initialValue() {
            return supplier.get();
        }
    }

此处建议使用 withInitial 方法来初始化 ThreadLocal 变量的值

注：如果不初始化 ThreadLocal 变量的值，那么他默认就是 ThreadLocal 的 initialValue 方法返回的值（也就是 null），这样可能引发NPE（空指针异常）。

ThreadLocal 源码分析

我们先从 get 方法入手

public T get() {
	// 获取当前线程对象
    Thread t = Thread.currentThread();
    // 通过当前线程对象获取 ThreadLocalMap 
    // ThreadLocalMap 对象是 ThreadLocal 的一个静态内部类，其实现和 Map 差不多 
    ThreadLocalMap map = getMap(t);
    if (map != null) { // 如果 map 不为空，说明当前线程已经有副本值了
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {// 如果当前副本值不为空，则返回该值
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 如果当前副本值为空，则执行初始化方法 setInitialValue
    return setInitialValue();
}

setInitialValue 方法逻辑

private T setInitialValue() {
	// 执行 initialValue 方法，获取初始值
    T value = initialValue();
    Thread t = Thread.currentThread();
    // 获取当前线程的 ThreadLocalMap 对象
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);// 如果 ThreadLocalMap 为空，则执行 createMap 创建该对象
    return value;
}

以上涉及到两个 ThreadLocalMap 的操作，getMap 和 createMap

    ThreadLocalMap getMap(Thread t) {
    	// 直接返回 t 线程的 threadLocals 属性
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
    	// 设置 t 线程的 threadLocals 属性为 new ThreadLocalMap
    	// ThreadLocalMap 的 key 值为 this（当前 ThreadLocal 对象）
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

在 Thread 类中对应的 threadLocals 字段定义如下：

 ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal set 方法逻辑

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

threadLocals 在 Thread 初始化时，是为空的，在某个 ThreadLocal 对象第一次调用 get 或 set 方法时，创建并赋值的。

源码分析总结

在这里插入图片描述

内存泄漏问题

在此，请大家先回顾一下我们在 JVM 专栏《JVM GC 垃圾收集器》一章中提到的几种引用的类型（强软弱虚），以及它们在 GC 时的特点，这样有助于理解该问题。

其实 ThreadLocal 在我们上面的示例中的引用关系，除了在线程中（我们上面总结的引用关系图），还有就是在我们的 car 对象中，所以最终我们的引用图是这样的

在这里插入图片描述

来说明一下：

  • threadLocals：是 Thread 对象中的字段强引用，类型为：ThreadLocal.ThreadLocalMap，其中存放了 ThreadLocal.ThreadLocalMap.Entry
  • color：是我们自定义对象 Car 中的字段强引用，类型为：ThreadLocal，它用作 ThreadLocal.ThreadLocalMap.Entry 的 Key

示例说明

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadLocalTest2 {


    public static void main(String[] args) throws InterruptedException {

        /*
        核心线程为：2
        最大线程数为：2
        救急线程最长空闲时间：0 秒
        阻塞队列使用固定容量的 LinkedBlockingQueue ，容量为 10
        线程工厂使用 Spring 提供的 CustomizableThreadFactory ，并定义线程的前缀为：my-thread-pool-
         */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,2,0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10),new CustomizableThreadFactory("my-thread-pool-"));


        // pool 线程池方式
        pool.execute(()->log.debug("{}",new Car()));

        // new Thread 方式
//        new Thread(()->log.debug("{}",new Car())).start();

        // 等待以上线程执行完成（当然我们可以使用 FutureTask 来 get 这里我们只是示例而已，请不要较真）
        TimeUnit.SECONDS.sleep(2);
        System.gc();
        log.debug("GC 方法已执行");
        // new Thread 方式在此处要等待 GC 完成
        // pool 方法不用是因为，我们没有关闭线程池，当前程序不会结束
        TimeUnit.SECONDS.sleep(2);


    }


    @Slf4j
    @Getter
    @Setter
    @ToString
    static class Skeleton{
        /**
         * 颜色
         */
        private String color;

        public Skeleton(String color) {
            this.color = color;
        }


        @Override
        protected void finalize() throws Throwable {

            log.debug("{}，被 GC 了,方法对象：{}",this,"Skeleton");

        }
    }

    @Slf4j
    @Getter
    @Setter
    @ToString
    static class Car{

        /**
         * 我们这里给 ThreadLocal 一个初始化值
         */
        private ThreadLocal<Skeleton> skeleton = new ThreadLocal<Skeleton>(){
            @Override
            protected Skeleton initialValue() {
                return new Skeleton("黑色");
            }

            // 重写 ThreadLocal 的 finalize 方法，看看它什么时候被 GC
            @Override
            protected void finalize() throws Throwable {

                log.debug("{}，被 GC 了,方法对象：{}",this,"ThreadLocal");

            }
        };

        public Car(){

        }

        public Car(Skeleton skeleton){
            this.setSkeleton(skeleton);
        }

        public void setSkeleton(Skeleton skeleton) {
            this.skeleton.set(skeleton);
        }

        public Skeleton getSkeleton() {
            return this.skeleton.get();
        }

        @Override
        protected void finalize() throws Throwable {

            log.debug("{}，被 GC 了,方法对象：{}",this,"Car");

        }
    }

}

new Thread 方式 执行结果

14:59:45.990 [Thread-0] DEBUG com.yyoo.thread.ThreadLocalTest2 - ThreadLocalTest2.Car(skeleton=ThreadLocalTest2.Skeleton(color=黑色))
14:59:48.004 [main] DEBUG com.yyoo.thread.ThreadLocalTest2 - GC 方法已执行
14:59:48.004 [Finalizer] DEBUG com.yyoo.thread.ThreadLocalTest2$Skeleton - ThreadLocalTest2.Skeleton(color=黑色)，被 GC 了,方法对象：Skeleton
14:59:48.004 [Finalizer] DEBUG com.yyoo.thread.ThreadLocalTest2$Car - com.yyoo.thread.ThreadLocalTest2$Car$1@6dfb5a1c，被 GC 了,方法对象：ThreadLocal
14:59:48.004 [Finalizer] DEBUG com.yyoo.thread.ThreadLocalTest2$Car - ThreadLocalTest2.Car(skeleton=ThreadLocalTest2.Skeleton(color=黑色))，被 GC 了,方法对象：Car

new Thread 执行后，可以看到 GC 时

  • Car 对象被回收了
  • ThreadLocal 对象本身被回收了
  • ThreadLocal 对应的 value Skeleton 也被回收了。

代码中用到的对象都正常回收完成。

pool 方式执行结果

15:24:08.012 [my-thread-pool-1] DEBUG com.yyoo.thread.ThreadLocalTest2 - ThreadLocalTest2.Car(skeleton=ThreadLocalTest2.Skeleton(color=黑色))
15:24:10.040 [main] DEBUG com.yyoo.thread.ThreadLocalTest2 - GC 方法已执行
15:24:10.040 [Finalizer] DEBUG com.yyoo.thread.ThreadLocalTest2$Car - com.yyoo.thread.ThreadLocalTest2$Car$1@6dfb5a1c，被 GC 了,方法对象：ThreadLocal
15:24:10.040 [Finalizer] DEBUG com.yyoo.thread.ThreadLocalTest2$Car - ThreadLocalTest2.Car(skeleton=ThreadLocalTest2.Skeleton(color=黑色))，被 GC 了,方法对象：Car
  • Car 对象被回收了
  • ThreadLocal 对象本身被回收了
  • ThreadLocal 对应的 value Skeleton 没有被回收

原因解析

new Thread 方式正常回收，是因为，线程执行完成后，Thread 对象执行完了，会被回收。而 pool 方式执行完成后，线程会回到线程池，而不是关闭线程，该线程还可能执行其他任务。这意味着这个线程对应的 threadLocals 不会被释放（如果我们没有手动将其赋值为 null 手动释放的话）。我们上面提到了 threadLocals 是强引用，所以它是不会被释放的，threadLocals 没有被释放，那么 ThreadLocal 对象为啥被释放了？它不是 threadLocals ThreadLocal.ThreadLocalMap.Entry 的key 值吗？我们来看一眼 ThreadLocal.ThreadLocalMap.Entry 的源码定义

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** ThreadLocal 对应到 value 值 */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

通过 Entry 对象的定义，我们知道 Entry 对象是一个弱引用对象，其引用的值是 ThreadLocal 对象，而 ThreadLocal 对象是 Entry 的 key 值。弱引用对象在每次 GC 时，都会被回收。所以 GC 之后，ThreadLocal 对象被回收了，Entry 对应的 key 值就为空了。但是，这里的 Object value 是不会被回收的，因为通过 threadLocals ThreadLocal.ThreadLocalMap，还是能引用过来，导致 value 值还存在。

总结

所以，在使用线程池的情况下使用 ThreadLocal 我们需要按照如下方式来使用

pool.execute(() -> {
    ThreadLocal<String> tl = null;
    try {
        tl = ThreadLocal.withInitial(() -> "测试");
    }finally {
        if(tl != null){
        	// 通过 remove 方法清除 ThreadLocal 对象的局部变量值
        	// 调用 remove 过后，如果再次 get，会再次重新执行 initialValue 方法，重新初始化
            tl.remove();
        }
    }
});

所以，我们得将我们的示例程序修改一下：

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadLocalTest2 {


    public static void main(String[] args) throws InterruptedException {

        /*
        核心线程为：2
        最大线程数为：2
        救急线程最长空闲时间：0 秒
        阻塞队列使用固定容量的 LinkedBlockingQueue ，容量为 10
        线程工厂使用 Spring 提供的 CustomizableThreadFactory ，并定义线程的前缀为：my-thread-pool-
         */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,2,0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10),new CustomizableThreadFactory("my-thread-pool-"));


        // pool 线程池方式
        pool.execute(()-> {
            Car car = null;
            try {
                car = new Car();
                log.debug("{}", car);
            }finally {
                if(car != null) {
                    car.remove();
                }
            }
        });

        // new Thread 方式
//        new Thread(()->log.debug("{}",new Car())).start();

        // 等待以上线程执行完成（当然我们可以使用 FutureTask 来 get 这里我们只是示例而已，请不要较真）
        TimeUnit.SECONDS.sleep(2);
        System.gc();
        log.debug("GC 方法已执行");
        // new Thread 方式在此处要等待 GC 完成
        // pool 方法不用是因为，我们没有关闭线程池，当前程序不会结束
        TimeUnit.SECONDS.sleep(2);


    }


    @Slf4j
    @Data
    static class Skeleton{
        /**
         * 颜色
         */
        private String color;

        public Skeleton(String color) {
            this.color = color;
        }


        @Override
        protected void finalize() throws Throwable {

            log.debug("{}，被 GC 了,方法对象：{}",this,"Skeleton");

        }
    }

    @Slf4j
    @Data
    static class Car{

        /**
         * 我们这里给 ThreadLocal 一个初始化值
         */
        private ThreadLocal<Skeleton> skeleton = new ThreadLocal<Skeleton>(){
            @Override
            protected Skeleton initialValue() {
                return new Skeleton("黑色");
            }

            // 重写 ThreadLocal 的 finalize 方法，看看它什么时候被 GC
            @Override
            protected void finalize() throws Throwable {

                log.debug("{}，被 GC 了,方法对象：{}",this,"ThreadLocal");

            }
        };

        public Car(){

        }

        public Car(Skeleton skeleton){
            this.setSkeleton(skeleton);
        }

        public void setSkeleton(Skeleton skeleton) {
            this.skeleton.set(skeleton);
        }

        public Skeleton getSkeleton() {
            return this.skeleton.get();
        }

        public void remove(){
            this.skeleton.remove();
        }

        @Override
        protected void finalize() throws Throwable {

            log.debug("{}，被 GC 了,方法对象：{}",this,"Car");

        }
    }

}

执行结果：

08:29:52.113 [my-thread-pool-1] DEBUG com.yyoo.thread.ThreadLocalTest2 - ThreadLocalTest2.Car(skeleton=ThreadLocalTest2.Skeleton(color=黑色))
08:29:54.133 [main] DEBUG com.yyoo.thread.ThreadLocalTest2 - GC 方法已执行
08:29:54.133 [Finalizer] DEBUG com.yyoo.thread.ThreadLocalTest2$Skeleton - ThreadLocalTest2.Skeleton(color=黑色)，被 GC 了,方法对象：Skeleton
08:29:54.133 [Finalizer] DEBUG com.yyoo.thread.ThreadLocalTest2$Car - com.yyoo.thread.ThreadLocalTest2$Car$1@6dfb5a1c，被 GC 了,方法对象：ThreadLocal
08:29:54.133 [Finalizer] DEBUG com.yyoo.thread.ThreadLocalTest2$Car - ThreadLocalTest2.Car(skeleton=ThreadLocalTest2.Skeleton(color=黑色))，被 GC 了,方法对象：Car

很多地方（阿里开发规约中也有）都有这样一个建议：ThreadLocal 对象建议使用 static 修饰。这个变量是针对一个线程内所有操作共享的，所以设置为静态变量，所有此类实例共享此静态变量 ，也就是说在类第一次被使用时装载，只分配一块存储空间，所有此类的对象(只要是这个线程内定义的)都可以操控这个变量。

在我们的示例下，如果将 ThreadLocal 对象用 static 修饰，我们即便调用了 remove 方法，value 对象也不会被释放，且 ThreadLocal 对象都不会被释放了。 此处请大家自行判断吧，或许此处有我没有理解到的地方，请大家指正，但我依照我们的示例代码结果来总结，虽然用 static 修饰，在分配时只需要一块存储空间，但它无法释放已分配的空间，也可能导致内存泄漏。

没事儿写两篇
关注
  • 13
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入浅析Random类在高并发下的缺陷及JUC对其的优化
08-26
ThreadLocalRandom类通过使用ThreadLocal变量来存储每个线程的私有Random实例，确保了在多线程环境下的独立性。每个线程都有自己的种子，不会因其他线程的影响而产生重复的随机数。ThreadLocalRandom不仅解决了并发...
Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf
07-26
- ThreadLocalHoldCounter是ThreadLocal的一个子类，每个线程都有自己的HoldCounter实例，用于存储当前线程的读锁重入计数。这样可以确保线程间读锁计数的隔离，避免并发问题。 5. **写锁和读锁的获取与释放** - ...
JUC ThreadLocal源码行级解析 JDK8
anlian523的博客
04-19 1545
ThreadLocal看类名就是线程本地变量的意思。从使用上来说，如果定义了一个ThreadLocal，那么各个线程针对这个ThreadLocal进行get/set都是线程独立的，也就是说，是线程隔离的本地变量。 从实现上来说，每个线程在运行过程中都可以通过Thread.currentThread()获得与之对应的Thread对象，而每个Thread对象都有一个ThreadLocalMap类型的成员，ThreadLocalMap是一种hashmap，它以ThreadLocal作为key。所以，通过Thre
JUC ThreadLocal源码解析
stay foolish
02-03 78
首先，我们在spring中，一般业务类生成的bean都是单例模式，每个业务bean只有一个对象，故而只有一个ThreadLocal对象. public class BusinessBean { public static final ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>(){ @Override protected Integer initialValue()
JUC并发编程——ThreadLocal
weixin_39555954的博客
01-14 315
一、
JUC-ThreadLocal
weixin_39248750的博客
06-07 157
针对共享资源的线程安全问题，ThreadLocal可以实现资源对象的线程隔离，让每个线程各用各的资源对象，避免争用引发的线程安全问题，并且还可以实现线程内资源共享。具体原理如下图： 每个线程内又一个ThreadLocalMap类型的成员变量，用来存储资源对象。可看出ThreadLocalMap是ThreadLocal的内部静态类，而它的构成主要是用Entry来保存数据 ，而且还是继承的弱引用。在Entry内部使用ThreadLocal作为key，使用我们设置的value作为value。
practice:知识梳理：数据结构和算法，leetcode解题记录，手写生产者-消费者模型，SpringAOP，Springboot自定义注释解，异常异常处理，整合Mybatis，整合Redis，mybatis逆向工程，死锁，同步锁，读-写同步锁，BIO，NIO，AIO，Netty服务，客户端，ThreadLocal使用，23种设计模式（未完待续...），生成XML文件，接口并发测试，Kafka生产者消费者示例（持续更新）。 ..）
03-18
本工程包含了SpringAOP，死锁，JUC同步锁，读-写同步锁，线程本地使用，JUC线程池和Spring提供的线程池，jdk 1.8中的日期时间API，数据结构中图的实现及操作和广度优先遍历/深度优先遍历（其他待完善），生成XML文件...
Tech_Diagrams:初步技术-核心知识点-逐步原理归纳总结图
03-20
技术图基于draw.io的新版本图化-初级技术核心知识点...锁4.GC 5.JVM运行时数据区6.AQS及相关类-各种关系和流程图7.ThreadLocal卡夫卡雷迪斯卡桑德拉弹性搜寻分散1.多样性事务2.分布式锁3.数据与缓存一致性4.一致性算法
java8源码-note:笔记
06-04
ThreadLocal的问题根源 2.5 Classloader的秘密 2.6 JUC之Atomic 2.7 锁 2.8 Java生产环境中把xmx和xms设置成一样有什么样的好处？ 2.9 spring 5 响应式编程 2.10 关于Seata实现分布式事务 2.11 主流注册中心对比 ...
基于Java的五子棋游戏的设计(源代码+论文).zip
06-25
基于Java的五子棋游戏的设计(源代码+论文)
智能制造整体解决方案.pptx
06-25
智能制造整体解决方案.pptx
在Ubantu18.04中搭建Gazebo仿真环境.zip
06-25
在Ubantu18.04中搭建Gazebo仿真环境
2023-04-06-项目笔记 - 第一百七十五阶段 - 4.4.2.173全局变量的作用域-173 -2024.06.25
06-25
2023-04-06-项目笔记-第一百七十五阶段-课前小分享_小分享1.坚持提交gitee 小分享2.作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.173局变量的作用域_173- 2024-06-25
Android应用多抽屉界面效果实现
最新发布
06-25
这是关于Android平台上实现多抽屉效果的资源文件，其界面类似于老版QQ的应用方式。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
Python运维开发.zip
06-25
python安装
2024年欧洲环戊烷市场主要企业市场占有率及排名.docx
06-25
2024年欧洲环戊烷市场主要企业市场占有率及排名.docx
这是用于在Multisim中创建LM386电路所需的符号文件
06-25
本资源提供了在Multisim设计软件中创建LM386电路所必需的符号文件。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
某大型企业智能制造数字化车间整体解决方案2.pptx
06-25
某大型企业智能制造数字化车间整体解决方案2.pptx
Java-JUC-多线程 进阶
07-05
来自B站 遇见狂神说

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值