java多线程总结-线程池

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量137 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/LionElegy/p/11223921.html
版权

目录

1 准备知识

介绍线程池之前先简要了解一下Executor，ExecutorService，Future，Callable，Executors是什么，和线程池又有什么关系

1.1 Executor

它是线程池顶级接口。它定义了一个方法void execute(Runnable)。
1646196-20190722230658741-1435984136.png

这个方法是用于处理任务的一个服务方法，调用者提供Runnable接口的实现，线程池通过线程执行这个Runnable，该服务方法是无返回值的

1.2 ExecutorService

1646196-20190722230705926-221630250.png

ExecutorService是Executor接口的子接口，它提供了一个新的服务方法submit，是有返回值的，返回值类型为Future类型（关于Future见1.3），它提供返回值主要是由Callable的call方法提供返回值（Callable见1.4） ，所有的线程池类型都实现这个接口

1.3 Future

顾名思义，Future->未来,代表线程任务执行结束后的结果。
获取线程执行结果的方式是通过get方法获取的，get有两种方式，有参和无参
1646196-20190722230801339-1906972863.png

无参T get()->阻塞等待线程执行结束，并得到结果。
有参T get(long, TimeUnit)->阻塞固定时长，等待线程执行结束后的结果，如果在阻塞时长范围内，线程未执行结束，抛出异常。

1.4 Callable

Callable类似Runnable接口，它有一个call方法，它的作用和Runnable中的run方法完全一致，但也有区别
Callable的call->有返回值，可以抛出任意异常
Runnable的run-> 无返回值，不能抛出未检查的异常
1646196-20190722230813422-1788276578.png

call方法的返回值就是Future中get方法的返回值

1.5 Executors

Executors是一个工具类，类似Collection和Collections的关系，可以更简单的创建若干种线程池，通过Executors可以直接得到想要的线程池

1646196-20190722230826424-2090631872.png

2 线程池

线程池状态： Running， ShuttingDown， Termitnaed

  • Running - 线程池正在执行中。活动状态。
  • ShuttingDown - 线程池正在关闭过程中。优雅关闭。一旦进入这个状态，线程池不再接收新的任务，处理所有已接收的任务，处理完毕后，关闭线程池。
  • Terminated - 线程池已经关闭。

2.1 固定容量线程池FixedThreadPool

FixedThreadPool是固定容量线程池，创建线程池的时候容量固定，使用的是BlockingQueue作为任务的载体，线程池默认的容量上限是Integer.MAX_VALUE

  • 特点：当任务数量大于线程池容量的时候，没有运行的任务保存在任务队列中，当线程有空闲的，自动从队列中取出任务执行
  • 使用场景： 大多数情况下，使用的线程池，首选推荐FixedThreadPool。OS系统和硬件是有线程支持上限。不能随意的无限制提供线程池。

下面是一个无返回值的小案例：
案例中创建了一个线程池，容量为5，执行6个任务，分析调用shutdown方法后，分析任务的执行情况

/**
 * 线程池
 * 固定容量线程池
 */
package com.bernardlowe.concurrent.t08;

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

public class Test_02_FixedThreadPool {
    
    public static void main(String[] args) {
        ExecutorService service = 
                Executors.newFixedThreadPool(5);
        for(int i = 0; i < 6; i++){
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.MILLISECONDS.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " - test executor");
                }
            });
        }
        
        System.out.println("初始状态：" + service);

        System.out.println("开始调用shutdown方法=====");
        service.shutdown();
        // 是否已经结束， 相当于回收了资源。
        System.out.println("是否terminated：" + service.isTerminated());
        // 是否已经关闭， 是否调用过shutdown方法
        System.out.println("是否shutdown：" + service.isShutdown());
        System.out.println("shutdown后的状态：" + service);
        
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // service.shutdown();
        System.out.println("2秒过后任务全部执行完====");
        System.out.println("是否terminated：" + service.isTerminated());
        System.out.println("是否shutdown：" + service.isShutdown());
        System.out.println("任务全部执行完过后状态：" + service);
    }

}

结果：
1646196-20190722230852638-387518545.png

从图中可以分析出以下几个过程
在初始状态：五个执行线程，1个任务在等待队列，0个完成任务
↓
调用shutdown方法后：线程池未关闭（terminated为false），调用了shutdown（不再接收新任务），0个完成任务
↓
两秒后任务执行完毕：线程池已关闭（terminated为true），调用了shutdown（不再接收新任务），6个完成任务

下面是一个有返回值的小案例：
案例中创建了一个线程池，容量为1，submit方法传了一个Callable,future通过get获取线程的返回值

/**
 * 线程池
 * 固定容量线程池（有返回值）
 */
package com.bernardlowe.concurrent.t08;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class Test_03_Future {
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        
        ExecutorService service = Executors.newFixedThreadPool(1);

        Future<String> future = service.submit(new Callable<String>() {
            @Override
            public String call() {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return Thread.currentThread().getName() + " - test executor";
            }
        });
        System.out.println("线程是否结束: " + future.isDone()); // 查看线程是否结束， 任务是否完成。 call方法是否执行结束

        System.out.println("call方法的返回值: " + future.get()); // 获取call方法的返回值。
        System.out.println("线程是否结束: " + future.isDone());

        // 关闭线程池
        service.shutdown();
    }

}

结果：
1646196-20190722230907189-1820880238.png

2.2 CachedThreadPool

缓存的线程池, 容量不限（Integer.MAX_VALUE）,自动扩容
容量管理策略：如果线程池中的线程数量不满足任务执行，创建新的线程。每次有新任务无法即时处理的时候，都会创建新的线程。当线程池中的线程空闲时长达到一定的临界值（默认60秒），自动释放线程，这里通过Executors.newCachedThreadPool()方法得到的线程池无法修改空闲时间，具体原因见下图，但可以通过自定义线程池ThreadPoolExecutor修改，具体方法见2.5，这里就不解释了

1646196-20190722230916960-427135436.png

应用场景： 内部应用或测试应用。

  • 内部应用，有条件的内部数据瞬间处理时应用，如：电信平台夜间执行数据整理（有把握在短时间内处理完所有工作，且对硬件和软件有足够的信心）。
  • 测试应用，在测试的时候，尝试得到硬件或软件的最高负载量，用于提供FixedThreadPool容量的指导

案例演示：

/**
 * 线程池
 * 无容量限制的线程池（最大容量默认为Integer.MAX_VALUE）
 */
package com.bernardlowe.concurrent.t08;

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

public class Test_05_CachedThreadPool {
    
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        
        System.out.println(service);
        
        for(int i = 0; i < 5; i++){
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.MILLISECONDS.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " - test executor");
                }
            });
        }
        
        System.out.println(service);
        
        try {
            TimeUnit.SECONDS.sleep(65);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println(service);
    }

}

2.3 计划任务线程池ScheduledThreadPool

ScheduledThreadPool是计划任务线程池，可以根据计划自动执行任务的线程池，底层实现是一个DelayedWorkQueue，它的一个主要方法scheduleAtFixedRate
1646196-20190722230933233-1385560144.png

有以下几个参数：

  • command - 要执行的任务
  • initialDelay - 第一次任务执行的间隔。
  • period - 多次任务执行的间隔。
  • unit - 多次任务执行间隔的时间单位。

案例：

/**
 * 线程池
 * 计划任务线程池。
 */
package com.bernardlowe.concurrent.t08;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test_07_ScheduledThreadPool {
    
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(3);
        System.out.println(service);
        
        // 定时完成任务。 scheduleAtFixedRate(Runnable, start_limit, limit, timeunit)
        // runnable - 要执行的任务。
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }, 0, 300, TimeUnit.MILLISECONDS);
        
    }

}

2.4 单一容量的线程池SingleThreadExecutor

单一容量的线程池，用法和FixedThreadPool类似，但和newFixedThreadPool不一样的是newSingleThreadExecutor创建的线程池又被一个FinalizableDelegatedExecutorService包装了一下
总结一下SingleThreadExecutor：

  • 单线任务处理的线程池
  • shutdown方法必然会被调用
  • 不具备ThreadPoolExecutor所有功能的线程池
    具体可以看看这篇文章：https://www.jianshu.com/p/2b7d853322bb

2.5 分支合并线程池ForkJoinPool

分支合并线程池（mapduce类似的设计思想），可以递归完成复杂任务，适合用于处理复杂任务
要求可分支合并的任务必须是ForkJoinTask类型的子类型
ForkJoinTask类型提供了两个抽象子类型：
RecursiveTask有返回结果的分支合并任务
RecursiveAction无返回结果的分支合并任务

案例：
这个案例做了一个以ForkJoinPool实现的数据累加，当计算数字区间大于MAX_SIZE=50000时，开启新的线程任务的计算，最后合并统计结果

/**
 * 线程池
 * 分支合并线程池。
 */
package com.bernardlowe.concurrent.t08;

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class Test_08_ForkJoinPool {
    
    final static int[] numbers = new int[1000000];
    final static int MAX_SIZE = 500000;
    final static Random r = new Random();
    
    
    static{
        for(int i = 0; i < numbers.length; i++){
            numbers[i] = r.nextInt(1000);
        }
    }
    
    static class AddTask extends RecursiveTask<Long>{ // RecursiveAction
        int begin, end;
        public AddTask(int begin, int end){
            this.begin = begin;
            this.end = end;
        }
        
        // 
        protected Long compute(){
            if((end - begin) < MAX_SIZE){
                long sum = 0L;
                for(int i = begin; i < end; i++){
                    sum += numbers[i];
                }
                // System.out.println("form " + begin + " to " + end + " sum is : " + sum);
                return sum;
            }else{
                int middle = begin + (end - begin)/2;
                AddTask task1 = new AddTask(begin, middle);
                AddTask task2 = new AddTask(middle, end);
                task1.fork();// 就是用于开启新的任务的。 就是分支工作的。 就是开启一个新的线程任务。
                task2.fork();
                // join - 合并。将任务的结果获取。 这是一个阻塞方法。一定会得到结果数据。
                return task1.join() + task2.join();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException, ExecutionException, IOException {
        long result = 0L;
        for(int i = 0; i < numbers.length; i++){
            result += numbers[i];
        }
        System.out.println(result);
        
        ForkJoinPool pool = new ForkJoinPool();
        AddTask task = new AddTask(0, numbers.length);
        
        Future<Long> future = pool.submit(task);
        System.out.println(future.get());
        
    }

}

结果：该任务分类四个线程任务进行计算，最后汇总

1646196-20190722230956520-1121023386.png

2.5 ThreadPoolExecutor

ThreadPoolExecutor线程池的底层实现，除ForkJoinPool外，其他常用线程池底层都是使用ThreadPoolExecutor实现的，其中有一个构造方法如下：
1646196-20190722231020979-1874667115.png

  • corePoolSize：核心容量，创建线程池的时候，默认有多少线程。也是线程池保持的最少线程数
  • maximumPoolSize： 最大容量，线程池最多有多少线程
  • keepAliveTime： 生命周期，0为永久。当线程空闲多久后，自动回收
  • unit: 生命周期单位，为生命周期提供单位，如：秒，毫秒
  • workQueue 任务队列，阻塞队列。注意，泛型必须是Runnable

案例：

/**
 * 线程池
 * 固定容量线程池
 */
package com.bernardlowe.concurrent.t08;

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

public class Test_09_ThreadPoolExecutor {
    
    public static void main(String[] args) {
        // 模拟fixedThreadPool， 核心线程5个，最大容量5个，线程的生命周期无限。
        ExecutorService service = 
                new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, 
                        new LinkedBlockingQueue<Runnable>());
        
        for(int i = 0; i < 6; i++){
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.MILLISECONDS.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " - test executor");
                }
            });
        }
        
        System.out.println(service);
        
        service.shutdown();
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
        System.out.println(service);
        
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        service.shutdown();
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
        System.out.println(service);
        
    }
}

转载于:https://www.cnblogs.com/LionElegy/p/11223921.html

YP5426
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程简单应用-线程池
04-19
在Java编程中，多线程是一种重要的并发处理技术，它允许多个任务同时执行，以提高程序的效率和响应速度。线程池是多线程应用中的一个关键概念，它优化了线程的管理和资源利用。本文将深入探讨线程池的概念、其工作...
java多线程，对多线程，线程池进行封装，方便使用
05-16
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，我们可以通过实现Runnable接口或继承Thread类来创建线程。然而，直接使用线程可能存在一些问题，如资源管理...
JUC中线程池原理解析
c1523456的博客
07-12 203
JUC中线程池原理解析 首先我们先说一下一个线程池基本上会有哪些基本组件构成 线程管理器，即线程池，维护线程池中线程数量,当线程空闲数多时尽心线程的回收，当线程紧张时进行线程的创建 任务添加与拒绝策略 任务队列 BlockingQueue 线程的构造工厂 ThreadFactory 线程集合 worker 即线程中相当于runabble 的固定的模板方法 这里我写了一个简易版的线程池，便于让大家了解线程池原理，放到了csdn上 https://blog.csdn.ne
[JUC系列]彻底搞懂线程池
qq_41979344的博客
01-31 1338
使用线程池线程池的目的： 降低资源消耗：创建线程和销毁线程会占用系统资源 提高响应速度：创建线程和销毁线程需要占用时间 方便集中管理：为了防止滥用多线程，有个统一治理的地方 在《阿里巴巴 java 开发手册》中指出线程资源必须通过线程池提供，不允许在应用在显示的创建线程；而且线程池不允许使用 Executors 创建，要通过 ThreadPoolExecutor 方式，由于 jdk 中 Executor 框架虽然提供了如 newFixedThreadPool()、newSingleThreadExecu
Java多线程-线程池与Executor框架
LifeBackwards的专栏
04-12 257
目录 一 使用线程池的好处 二 Executor框架 2.1 简介 2.2 Executor 框架结构(主要由三大部分组成) 1 任务。 2 任务的执行 3 异步计算的结果 2.3 Executor框架的使用示意图 ​1. 主线程首先要创建实现Runnable或者Callable接口的任务对象。 2. 然后可以把创建完成的Runnable对象直接交给ExecutorServic...
java JUC 之 四种常用线程池 + Spring提供的线程池技术
古小龙
08-10 1009
目录 一. 线程池的概念 二. 使用线程池的原因 三. JUC常用四种创建线程池方式 四. 常见的四种线程池详解 五. 进一步应用 --> Spring提供的线程池技术ThreadPoolTaskExecutor的使用 六. 感谢大家的阅读！ 一. 线程池的概念 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线...
mark-超时重试
weixin_44592837的博客
06-01 1651
今天写了个超时重传的方法，用到了线程池，同时也记录一下踩过的坑。当队列也满时执行的拒绝策略： 因为我使用的是CallerRunsPolicy这个策略，但是当我执行完一轮任务 之后，发现一直抛出如下异常： 嗯哼？？?,线程终止，无论再怎么执行都是抛出这个异常。。。就开始找原因了，一开始还以为是CallerRunsPolicy这个拒绝策略我理解的有问题。。。后面才发现原来是，我在finally中加入了 shutdown()原来这个方法是会关闭线程池的，后面就会直接执行拒绝策略。。。 后面查了下资料，如果线程池的
JAVA并发编程实践-线程池-学习笔记
07-22
Java并发编程实践中的线程池是一个关键的概念，它在多线程编程中扮演着至关重要的角色，有效地管理和调度线程资源，以提高系统的性能和效率。线程池通过复用已存在的线程来减少线程的创建和销毁开销，避免了频繁的上...
Java多线程+线程池.docx
03-31
Java 多线程和线程池 Java 多线程是指在 Java 编程语言中，一个线程的动态执行过程。这个过程包括线程的创建、执行和销毁三个阶段。在 Java 中，创建线程有多种方式，包括通过实现 Runnable 接口、继承 Thread 类...
Java中的线程与线程池.pptx
01-20
在多线程环境下，可以实现并行和并发执行。并行是指多个独立的任务同时运行，而并发则是在同一时间段内交替执行多个任务，通常在单个CPU核心上实现。在具有共享资源的并发场景中，线程安全和同步变得至关重要，以...
Java 多线程高并发 3.4 — 线程池 ExecutorService、ScheduledExecutorService
锄禾日当午，啥都不靠谱；闲来没事做，不如写博客。
09-25 829
对于线程池的理解 简单理解就好，就一个池子 池子里面放着线程，需要的时候向池子要，用完归还回去 由于是资源重复利用，所以有助于提高系统性能，节约系统资源，是个好孩子 问题在于池子的管理，例如 线程不够用的时候怎么扩容？装得下吗？别人来要线程，要等多久？怎么控制线程的动向？别人一次要多个线程怎么办？空闲的线程怎么管理？其实如果单单使用的话就不用我们管了，java.util.concurrent 包...
java 实现线程有返回值 Callable 接口
10-12 1942
大家已经习惯用Runnable接口了，先看看Callable和Runnable接口的区别 /** *     * Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。      * Callab
JUC中几个常见的并发工具类详解
romantic_jie的博客
08-30 1909
在JDK的并发包里提供了几个非常有用的并发工具类。 其中CountDownLatch,CyclicBarrier和Semaphore工具类提供了一种并发控制的手段。 而Exchanger工具类则提供了在线程间进行交换数据的一种手段。 1.等待多线程完成的CountDownLatch CountDownLatch允许一个或多个线程等待其他线程完成操作。 定义抽象难理解，直接上测试代码！ ...
Java并发编程——多线程和线程池的那些坑
攻城狮Kevin
12-27 887
最近做HBase项目有一块涉及到Java的多线程安全的问题，于是回顾了一下java多线程的东西，看了多篇多线程的写的比较好的文章之后，对这一块的知识做一个回顾总结，并附上参考文章。 第一篇会写正题，ThreadLocal的原理和用法。 目录 一、程序 &amp; 进程 &amp; 线程 二、多线程的使用场景 三、 多线程的优点和缺点 1. 优点 2. 缺点 四、 多线程并行 &am...
【JUC源码】线程池：ThreadPoolExecutor（一）继承关系分析
A minor
02-23 513
在看 ThreadPoolExecutor 的源码前，我们先来看一下 ThreadPoolExecutor 的继承关系 1.Executor 定义 execute 方法来执行任务，入参是 Runnable，无出参 public interface Executor { void execute(Runnable command); } 2.ExecutorService Executor 的功能太弱，ExecutorService 丰富了对任务的执行和管理的功能，主要代码如下： public i
线程池学习
lzx_zlz的博客
09-09 127
背景：经常创建和销毁线程，消耗大量资源。 概念：首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。 优点：提高响应速度，降低资源消耗，便于线程管理。 一、创建线程池 1、execute方法用来执行实现Runnable接口的线程，无返回值 2、submit用来执行实现Callable接口的线程，有返.
JUC多线程：创建线程的四种方式
热门推荐
张维鹏的博客
01-18 1万+
Java多线程的实现方式主要有四种： （1）继承Thread类，重写run()； （2）实现Runnable接口，重写run()； （3）实现Callable接口，实现call() 方法，通过FutureTask包装器来创建Thread线程； （4）使用ExecutorService、Callable、Future实现有返回结果的多线程。
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1081
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 762
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Java多线程深入：线程池原理与Executor框架详解
本章节深入探讨了Java多线程编程的基础和Java.util.concurrent包中的Java Universal Classes (JUC) 对多线程的支持。主要内容包括以下几个关键知识点： 1. **线程池**：线程池是管理线程资源的关键概念，它通过预先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值