每日一博 - ThreadLocal VS InheritableThreadLocal VS TransmittableThreadLocal

最新推荐文章于 2024-06-10 18:46:47 发布
最新推荐文章于 2024-06-10 18:46:47 发布
阅读量2w 收藏 9
点赞数 4
分类专栏： 【每日一博】 文章标签： ThreadLocal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshangwei/article/details/119296005
版权

文章目录

在这里插入图片描述

ThreadLocal

位于java.lang包中的ThreadLocal 。

在这里插入图片描述

多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。

ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。

ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题

核心API

在这里插入图片描述

  • public T get(） 从线程上下文环境中获取设置的值
  • public void set(T value) 将值存储到线程上下文环境中，供后续使用
  • public void remove() 清除线程本地上下文环境

ThreadLocal类

在这里插入图片描述

在这里插入图片描述

【数据存储位置】

当线程调用 threadLocal 对象的 set(Object value) 方法时，数据并不是存储在 ThreadLocal 对象中，而是存储在 Thread 对象中，这也是 ThreadLocal 的由来，具体存储在线程对象的threadLocals 属性中，其类型为 ThreadLocal.ThreadLocalMap

【ThreadLocal.ThreadLocalMap】
Map 结构，即键值对，键为 threadLocal 对象，值为需要存储到线程上下文的值(threadLocal#set)方法的参数

源码分析

set

   public void set(T value) {
   		// 获取当前线程 
        Thread t = Thread.currentThread();
         // 获取线程的 threadLocals 属性
        ThreadLocalMap map = getMap(t);
        // 如果不为空，设置k  v 
        if (map != null)
            map.set(this, value);
        else
        	// 初始化线程对象的 threadLocals,然后将 threadLocal:value 键值对存入线程对象的threadLocals 属性中。
            createMap(t, value);
    }

get

public T get() {
		// 获取当前线程 
        Thread t = Thread.currentThread();
        // 获取线程的 threadLocals 属性
        ThreadLocalMap map = getMap(t);
		// 如果线程对象的 threadLocals 属性不为空，则从该 Map 结构中，用 threadLocal 对象为键去查找值，如果能找到，则返回其 value 值，否则执行代码 setInitialValue()
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 果线程对象的 threadLocals 属性为空，或未从 threadLocals 中找到对应的键值对，则调用该方法执行初始化
        return setInitialValue();
    }

 private T setInitialValue() {
 		// 调用 initialValue() 获取默认初始化值，该方法默认返回 null，子类可以重写，实现线程本地变量的初始化。
        T value = initialValue();
        // 获取当前线程。
        Thread t = Thread.currentThread();
        // 获取该线程对象的 threadLocals 属性。
        ThreadLocalMap map = getMap(t);
        // 如果不为空，则将 threadLocal:value 存入线程对象的 threadLocals 属性中。
        if (map != null)
            map.set(this, value);
        else
        	// 否则初始化线程对象的 threadLocals,然后将 threadLocal:value 键值对存入线程对象的threadLocals 属性中。
            createMap(t, value);
        return value;
    }

/**
*
* 初始化线程对象的 threadLocals,然后将 threadLocal:value 键值对存入线程对象的threadLocals 属性中。
*/
  void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

remove

     public void remove() {
      // 获取该线程对象的 threadLocals 属性。
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
         // 移除
             m.remove(this);
     }

缺陷

ThreadLocal 无法在父子线程之间传递， 看源码我们也知道了，都是Thread.currentThread.

那我们来证明下吧

public class ThreadLocalTest {


    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {

        ThreadLocalTest threadLocalTest = new ThreadLocalTest();

        threadLocal.set("artisan Test");

        doSomething();

    }

    private static void doSomething() {
        System.out.println("threadLocal中的对象:" + threadLocal.get());

        new Thread(()->{
            System.out.println("开启子线程");
            System.out.println("子线程中获取threadLocal：" + threadLocal.get());
        }).start();

    }
}

在这里插入图片描述

在这里插入图片描述

InheritableThreadLocal

由于 ThreadLocal 在父子线程交互中子线程无法访问到存储在父线程中的值，无法满足某些场景的需求，比如链路跟踪

在这里插入图片描述

为了解决上述问题，JDK 引入了 InheritableThreadLocal，即子线程可以访问父线程中的线程本地变量，准确的说是子线程可以访问在创建子线程时父线程当时的本地线程变量，其实现原理是在创建子线程将父线程当前存在的本地线程变量拷贝到子线程的本地线程变量中。

源码解析

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
	.....
}

在这里插入图片描述

从类的继承层次来看，InheritableThreadLocal 只是在 ThreadLocal 的 get、set、remove 流程中，重写了 getMap、createMap 方法，整体流程与 ThreadLocal 保持一致，所以我们初步来看一下InheritableThreadLocal 是如何重写上述这两个方法的。

  /**
     * Get the map associated with a ThreadLocal.
     *
     * @param t the current thread
     */
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

和 ThreadLocal比一比
在这里插入图片描述

可以知道 ThreadLocal 操作的是 Thread 对象的 threadLocals 属性，而 InheritableThreadLocal 操作的是 Thread 对象的 inheritableThreadLocals 属性

   /**
     * Create the map associated with a ThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the table.
     */
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }

createMap 被执行的条件是调用 InheritableThreadLocal#get、set 时如果线程的inheritableThreadLocals 属性为空时才会被调用

咦 ，看到这里没啥用啊

在这里插入图片描述

InheritableThreadLocal 是如何继承自父对象的线程本地变量的呢？

那就得看 Thread#init 方法

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

		//  获取当前线程对象，即待创建的线程的父线程。
        Thread parent = currentThread();
          
         ........
         ........
         ........
        
        // 如果父线程的 inheritableThreadLocals 不为空并且 inheritThreadLocals 为 true(该值默认为true)，则使用父线程的 inherit 本地变量的值来创建子线程的 inheritableThreadLocals 结构，即将父线程中的本地变量复制到子线程中
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }

 static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

类似于 Map 的复制，只不过其在 Hash 冲突时，不是使用链表结构，而是直接在数组中找下一个为 null 的槽位

子线程默认拷贝父线程的方式是浅拷贝，如果需要使用深拷贝，需要使用自定义ThreadLocal，继承 InheritableThreadLocal 并重写 childValue 方法

那来验证下吧

public class InheritableThreadLocalTest {


    private static InheritableThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {

        InheritableThreadLocalTest threadLocalTest = new InheritableThreadLocalTest();

        threadLocal.set("artisan InheritableThreadLocal");

        doSomething();

    }

    private static void doSomething() {
        System.out.println("threadLocal中的对象:" + threadLocal.get());

        new Thread(()->{
            System.out.println("开启子线程");
            System.out.println("子线程中获取threadLocal：" + threadLocal.get());
        }).start();

    }
}

在这里插入图片描述
符合预期，在子线程中如愿访问到了在主线程中设置的本地环境变量。

局限性

InheritableThreadLocal 支持子线程访问在父线程的核心思想是在创建线程的时候将父线程中的本地变量值复制到子线程，即复制的时机为创建子线程时。

线程池能够复用线程，减少线程的频繁创建与销毁，如果使用 InheritableThreadLocal，那么线程池中的线程拷贝的数据来自于第一个提交任务的外部线程，即后面的外部线程向线程池中提交任务时，子线程访问的本地变量都来源于第一个外部线程，造成线程本地变量混乱

看个代码

package com.artisan.threadlocal;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;
 
public class Service {

    /**

     * 模拟tomcat线程池

     */

    private static ExecutorService tomcatExecutors = Executors.newFixedThreadPool(10);

    /**

     * 业务线程池，默认Control中异步任务执行线程池

     */

    private static ExecutorService businessExecutors = Executors.newFixedThreadPool(5);

    /**

     * 线程上下文环境，模拟在Control这一层，设置环境变量，然后在这里提交一个异步任务，模拟在子线程中，是否可以访问到刚设置的环境变量值。

     */
    private static InheritableThreadLocal<Integer> requestIdThreadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {

        for(int i = 0; i < 10; i ++ ) { // 模式10个请求，每个请求执行ControlThread的逻辑，其具体实现就是，先输出父线程的名称，  然后设置本地环境变量，并将父线程名称传入到子线程中，在子线程中尝试获取在父线程中的设置的环境变量

            tomcatExecutors.submit(new ControlThread(i));

        }

     //简单粗暴的关闭线程池
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        businessExecutors.shutdown();
        tomcatExecutors.shutdown();

    }

    /**

     * 模拟Control任务

     */

    static class ControlThread implements Runnable {

        private int i;

        public ControlThread(int i) {
            this.i = i;
        }

        @Override

        public void run() {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            requestIdThreadLocal.set(i);

            //使用线程池异步处理任务
            businessExecutors.submit(new BusinessTask(Thread.currentThread().getName()));

        }

    }

    /**

     * 业务任务，主要是模拟在Control控制层，提交任务到线程池执行

     */

    static class BusinessTask implements Runnable {

        private String parentThreadName;

        public BusinessTask(String parentThreadName) {

            this.parentThreadName = parentThreadName;

        }

        @Override

        public void run() {

            //如果与上面的能对应上来，则说明正确，否则失败
            System.out.println("parentThreadName:" + parentThreadName + ":" + requestIdThreadLocal.get());

        }

    }
}

在这里插入图片描述
子线程中出现出现了线程本地变量混乱的现象

在这里插入图片描述

TransmittableThreadLocal

在这里插入图片描述

TransmittableThreadLocal 是什么

TransmittableThreadLocal 是阿里巴巴开源的专门解决 InheritableThreadLocal 的局限性，实现线程本地变量在线程池的执行过程中，能正常的访问父线程设置的线程变量。

实现原理

从InheritableThreadLocal 不支持线程池的根本原因是 InheritableThreadLocal 是在父线程创建子线程时复制的，由于线程池的复用机制，“子线程”只会复制一次。要支持线程池中能访问提交任务线程的本地变量，其实只需要在父线程在向线程池提交任务时复制父线程的上下环境，那在子线程中就能够如愿访问到父线程中的本地遍历，实现本地环境变量在线程调用之中的透传，实现链路跟踪，这也就是 TransmittableThreadLocal 最本质的实现原理。

在这里插入图片描述

TransmittableThreadLocal 继承自 InheritableThreadLocal，接下来将从 set 方法为入口，开始探究TransmittableThreadLocal 实现原理

    @Override
    public final void set(T value) {
    	// 首先调用父类的 set 方法，将 value 存入线程本地遍历，即 Thread 对象的inheritableThreadLocals 中
        super.set(value);
        // may set null to remove value   如果 value 为空，则调用 removeValue() 否则调用 addValue。
        if (null == value) removeValue();
        else addValue();
    }


  private void addValue() {
  	// 当前线程在调用 threadLocal 方法的 set 方法(即向线程本地遍历存储数据时)，如果需要设置的值不为 null，则调用 addValue 方法，将当前 ThreadLocal 存储到 TransmittableThreadLocal 的全局静态变量 holder。
        if (!holder.get().containsKey(this)) { 
            holder.get().put(this, null); // WeakHashMap supports null value.
        }
    }

   private void removeValue() {
        holder.get().remove(this);
    }

看看holder

   private static InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>> holder =
            new InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>>() {
                @Override
                protected Map<TransmittableThreadLocal<?>, ?> initialValue() {
                    return new WeakHashMap<TransmittableThreadLocal<?>, Object>();
                }

                @Override
                protected Map<TransmittableThreadLocal<?>, ?> childValue(Map<TransmittableThreadLocal<?>, ?> parentValue) {
                    return new WeakHashMap<TransmittableThreadLocal<?>, Object>(parentValue);
                }
            };

从中可以看出，使用了线程本地变量，内部存放的结构为 Map<TransmittableThreadLocal<?>, ?>，即该对象缓存了线程执行过程中所有的 TransmittableThreadLocal 对象，并且其关联的值不为空
https://github.com/alibaba/transmittable-thread-local

在这里插入图片描述

测试

  	<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>transmittable-thread-local</artifactId>
            <version>2.10.2</version>
        </dependency>

 package com.artisan.threadlocal;

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.threadpool.TtlExecutors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class TTLTest {

    /**

     * 模拟tomcat线程池

     */

    private static ExecutorService tomcatExecutors = Executors.newFixedThreadPool(10);

    /**

     * 业务线程池，默认Control中异步任务执行线程池

     */

    private static ExecutorService businessExecutors = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(4)); // 使用ttl线程池，该框架的使用，请查阅官方文档。

    /**

     * 线程上下文环境，模拟在Control这一层，设置环境变量，然后在这里提交一个异步任务，模拟在子线程中，是否可以访问到刚设置的环境变量值。

     */

    private static TransmittableThreadLocal<Integer> requestIdThreadLocal = new TransmittableThreadLocal<>();

// private static InheritableThreadLocal<Integer> requestIdThreadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {

        for(int i = 0; i < 10; i ++ ) {

            tomcatExecutors.submit(new ControlThread(i));

        }

        //简单粗暴的关闭线程池
        try {

            Thread.sleep(3000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        businessExecutors.shutdown();

        tomcatExecutors.shutdown();

    }

    /**

     * 模拟Control任务

     */

    static class ControlThread implements Runnable {

        private int i;

        public ControlThread(int i) {

            this.i = i;

        }

        @Override

        public void run() {

            System.out.println(Thread.currentThread().getName() + ":" + i);

            requestIdThreadLocal.set(i);

            //使用线程池异步处理任务
            businessExecutors.submit(new BusinessTask(Thread.currentThread().getName()));

        }

    }

    /**

     * 业务任务，主要是模拟在Control控制层，提交任务到线程池执行

     */

    static class BusinessTask implements Runnable {

        private String parentThreadName;

        public BusinessTask(String parentThreadName) {
            this.parentThreadName = parentThreadName;
        }

        @Override

        public void run() {

            //如果与上面的能对应上来，则说明正确，否则失败
            System.out.println("parentThreadName:" + parentThreadName + ":" + requestIdThreadLocal.get());

        }

    }
}

在这里插入图片描述

在这里插入图片描述

参考： 全链路压测必备基础组件之线程上下文管理之“三剑客”

小小工匠
关注
专栏目录
【多线程编程】--ThreadLocal、InheritableThreadLocal(ITL)、TransmittableThreadLocal(TTL)解析
寻梦友的博客
02-11 644
最近项目中，有个同事开发中定义了一个全局变量，为了防止数据混乱【并发请求这个接口时不同线程操作，会影响变量值】，他加了一个锁，这就大大影响了性能。我默默推荐了ThreadLocal，说可以解决他的问题。最后他虽然用了ThreadLocal，但又遇到问题，说代码执行到后面发现值莫名被置空了【看了代码发现，为了不影响返回结果，异步执行了一部分业务】。。。。。基于项目中使用到了ThreadLocal，同时一些复杂的场景，所以这篇文章将介绍ThreadLocal系列的原理，以便更好的使用。
ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal 使用以及区别
昨日晨曦的博客
02-18 797
ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal 使用以及区别
juc--线程池
qq_17690301的博客
09-12 354
利用Executors类来创建三种线程池 这三种线程池分别是FixedThreadPool，SingleThread，CachedThreadPool 类型 特点 FixedThreadPool 可以指定固定的线程数的线程池 SingleThread 只提供一个线程的线程池 CachedThreadPool 能根据当前业务繁忙情况动态地增加和减少线程数的线程池 代码演示 /** * * @Title: testThree * @Description: 用
初识TransmittableThreadLocal
热门推荐
大鸡腿的博客
05-04 3万+
文章目录前言TransmittableThreadLocalmavendemo参考博客 前言 TransmittableThreadLocal是阿里开源的一个类，主要目的是处理父子线程变量不能共用的情况。ThreadLocal是跟当前线程挂钩的，所以脱离当前线程它就起不了作用。 ThreadLocal 场景：它的应用就是比如当前用户特有的一些属性，不能跟其他线程，用户共用。 Transmittab......
ThreadLocal分析五：InheritableThreadLocal
Chen_leilei的博客
12-15 3973
通过上面几篇文章的分析，大家已经了解了threadlocal的数据结构，以及源码分析。但是他有什么缺点呢？ 答案是threadlocal不能在父子线程中线程之间传递 public class ThreadLocalTest { private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>(); public static void main(String[] args) {
ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal解析
u013620635的博客
08-01 555
说起本地线程变量，我相信大家首先会想到的是JDK默认提供的ThreadLocal，用来存储在整个调用链中都需要访问的数据，并且是线程安全的。本文将详细介绍ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal，并剖析各自的优缺点。 1.ThreadLocal详解 ThreadLocal对外提供的API如下： //从线程上下文环境中获取...
InheritableThreadLocal 使用的问题及解决办法
09-30 2588
问题背景 最近公司负责的项目总是出现莫名其妙的串号的问题，具体表现是一次请求里日志却记录的多个userId（一次请都只会有一个userId），看了很久的报文，分析了很久的代码，终于有了点眉目。 问题分析 这类问题主要出现在一个主任务启动的多个线程并发执行造成的，执行分析使用的是 InheritableThreadLocal private static class InheritableThreadLocalContext extends InheritableThreadLocal<ThreadLo
JUC-并发编程22-ThreadLocal、InheritableThreadLocal与TransmittableThreadLocal
qq_29434541的博客
06-10 1117
在多线程编程中，我们常常需要在线程之间传递上下文信息。Java 提供了和来帮助管理线程局部变量，但在某些场景下，如线程池和异步执行中，这些工具存在一些局限性。让我们详细探讨这些问题的发展历程，并介绍最终的解决方案。在多线程编程中，和 `InheritableThreadLocal解决了线程局部变量的问题，但在复杂的线程池和异步执行场景下，这些工具存在局限性。通过捕获和恢复上下文信息，并包装线程池和任务，确保上下文的正确传递和清理，是一种有效的解决方案。
ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal
weixin_37862824的博客
11-06 2875
多线程访问同一个共享变量的时候容易出现并发问题，ThreadLocal是除了加锁这种同步方式之外的一种保证规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题。 使用ThreadLocal的最终目的还是为了得到安全的数据，下面分析下ThreadLocal的结构 一、在提到ThreadLocal前我们先看下Thread类以及属性 class T
Android 详解ThreadLocal及InheritableThreadLocal
08-31
ThreadLocal和InheritableThreadLocal是Java中两个非常重要的线程相关的类，它们在Android开发中也有广泛应用。本文将深入解析这两个概念以及它们在Android环境下的工作原理。 **ThreadLocal** 是一个线程局部变量...
java-threadlocal-profiler:从 code.google.compjava-threadlocal-profiler 自动导出
06-19
Java 线程本地分析器。 用于 Java 应用程序分析的小库。 收集同一伞下的所有性能指标，可以一起打印出来。 最好与一些日志框架一起使用。 核心没有任何依赖关系，因此可以位于类加载器层次结构的顶部。...
开题报告SpringBoot家具商城系统.docx
最新发布
11-02
毕业设计开题报告
Flask-2.2.3-py3-none-any.zip
11-02
Flask-2.2.3-py3-none-any.zip
编译器前端与后端设计.docx
11-02
编译原理试题
google-2.0.1.tar.gz
11-02
google-2.0.1.tar.gz
1Python 3 介绍（十五）-- Python函数.docx
11-02
1Python 3 介绍（十五）-- Python函数.docx
天气图绘制的相关nc数据与shp
11-02
天气图绘制的相关nc数据与shp ①绘制中国地图的shp，省界国界 https://docs.gmt-china.org/latest/dataset-CN/CN-border/ ②500hpa、1000hpa（地面）天气图的相关数据 高度层：https://cds-beta.climate.copernicus.eu/datasets/reanalysis-era5-pressure-levels?tab=download 地表：https://cds-beta.climate.copernicus.eu/datasets/reanalysis-era5-single-levels?tab=overview
Django-3.2.7-py3-none-any.whl
11-02
Django whl安装包，可以直接pip install安装即可，不再下载网络超时
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小工匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值