多线程

最新推荐文章于 2021-05-22 14:18:26 发布
最新推荐文章于 2021-05-22 14:18:26 发布
阅读量200 收藏 1
点赞数
分类专栏： 笔记 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AlarMi/article/details/105910837
版权
第一节-线程简介
一、程序、进程、线程的简介
  1. 程序：是指令与数据的有序集合，本身没有任何运行的含义，是一个静态概念；
  2. 进程（Process）：执行程序的一次执行过程，是一个动态概念，是系统分配资源的单位；
  3. 线程（Thread）：在一个进程中包含若干个线程，线程是CPU调度和执行的单位；
注意：很多多线程是模拟出来的；真正的多线程是指有多个CPU（多核），如服务器。模拟出的多线程，在同一个时间点只能执行一块代码，但是由于切换速度很快，就给人一种同时执行的错觉！（main方法就是一个主线程）。
二、本节核心知识点
  1. 线程就是独立的执行路径；
  2. 程序运行时，即使没有创建线程，后台也会有多个线程，如主线程、GC线程；
  3. main（）方法称之为主线程，为系统的入口，用于执行整个程序；
  4. 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统密切相关的，先后顺序是不能人为干预的；
  5. 对同一份资源进行操作时，会存在资源抢夺的问题，需要加入并发控制；
  6. 线程会带来额外的开销，如CPU的调度时间，并发控制开销；
  7. 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致；
第二节-线程的创建
一、创建线程的三种方式
  1. 继承Thread类
  2. 实现Runnable接口
  3. 实现Callable接口（了解一下即可）
二、方式①继承Thread类的方法创建并开启线程
2.1 步骤
  1. 自定义一个类继承Thread类
  2. 在类中重写run（）方法
  3. 创建线程对象，调用start（）方法启动线程。（start方法的底层就是调用了run方法）
2.2 代码实现：
//首先声明一个类
public class ThreadTest extends Thread{
    //继承Thread的类一定要重写run方法
    @Override
    public void run() {
        for(int i = 0; i < 100; i ++){
            System.out.println("I im IRON MAN！");
        }
    }
    //然后在主方法中创建线程对象，用线程对象调用start（）方法，即可开启线程！
    public static void main(String[] args){
        
        ThreadTest t1 = new ThreadTest();
        
        t1.start();
        /*
        在这里需要注意：想要有多线程的效果，
        必须使得主线程与多线程中相同的动作在多线程启动之后书写
        */
        for(int i = 0; i < 100; i ++){
            System.out.println("I im IRON MAN！");
        }  
    }   
}

注意：线程一旦启动并不一定立即执行，是由CPU安排调度的。

三、利用方式②创建多线程
3.1 步骤：
  1. 创建一个类，让这个类去实现Runnable接口；
  2. 在类中重写run（）方法；
  3. 创建本类对象t1，由于本类对象不能直接调用start（）方法，因此还需要一个Thread类对象；
  4. 创建线程对象-在构造方法中丢入上面的t1，然后即可调用start（）方法来启动线程。
3.2 代码实现
public class C04_CreatThread_02 implements Runnable{
    @Override
   /*重写run方法*/
    public void run() {
        for(int i = 0; i < 249; i ++){
            System.out.println("I am doing my job!");
        }
    }
    /*主线程*/
    public static void main(String[] args) {
        /*创建一个本类对象*/
        C04_CreatThread_02 t1 = new C04_CreatThread_02();
        /*将本类对象丢入Thread类的创建中*/
        Thread t = new Thread(t1);
        /*用Thread去启动多线程*/
        t.start();
        /*这个是主线程的任务*/
        for(int i = 0; i < 238; i ++){
            System.out.println("I wang go to XIAN！");
        }
    }
}

像上面这种间接通过Thread类去调用start（）方法，可以将Thread的对象称之为代理。

Thread与Runnable的关系是：Thread类实现了Runnable接口，更推荐使用实现Runnable接口的方式去实现多线程，因为Java是单继承的，第一种方式会限制了类不能再继承其他类！

3.3 方式①②的对比：
方式①：继承Thread方式②：实现Runnable接口
子类继承Thread类，让子类拥有了多线程的能力；实现Runnable接口，使类有了多线程的能力；
启动线程：子类对象.start（）；启动线程:传入目标对象+Thread对象.start（）
不建议使用，避免OOP单继承局限性。推荐使用，避免单继承局限，方便同一个对象被多个线程使用。

方式②的优越性：同一个对象，能被多个线程同时处理，提高速度：

如下代码：一个实现了Runnable（）接口的类所创建的对象，通过代理被多个线程处理。

C04_CreatThread_02 tt = new C04_CreatThread_02();

Thread t1 = new Thread(tt,"WanLi");//这里是把线程起名字为：WanLi
Thread t2 = new Thread(tt,"LuoYan");
t1.start();
t2.start();
3.4 需求实例

需求①：实现多个人买票的场景：

public class C01_ThreadCreatTest implements Runnable {
    private int ticket = 10;
    @Override
    public void run() {
        while (true){
            if(ticket <= 0){
                break;
            }
            //这里利用了Thread.currentThread().getName()来获取当前线程的名字
            System.out.println(Thread.currentThread().getName() + "抢到了第" + (ticket --) + "票！");
        }
    }
    public static void main(String[] args) {
        /*在这里创建线程对象，并利用Thread代理来完成多线程*/
        C01_ThreadCreatTest tt = new C01_ThreadCreatTest();
        /*下面用三个线程，对这个对象的票进行操作。*/
        Thread t1 = new Thread(tt, "WanLi");
        Thread t2 = new Thread(tt, "LuoJia");
        Thread t3 = new Thread(tt, "LuoYan");
        /*三个线程开启*/
        t1.start();
        t2.start();
        t3.start();
    }
}
四、以实现Callable接口的方式实现多线程（了解一下即可）
4.1 步骤
/*第1步：实现Callable接口*/
/*第2步：重写call()方法，需要抛出异常，这里的返回值类型可以自己定，表示该方法执行时返回某个数据！*/
	public Object call() throws Exception {
        return null;
    }
/*第3步：创建目标对象*/
/*第4步：创建执行服务*/
	ExecutorService ser = Executors.newFixedThreadPool(1);//这里的数字代表开启几个线程
/*第5步：提交执行*/
	Future<Boolean> result1 = ser.submit(tt);
/*第6步：获取结果：*/
	Boolean r1 = result1.get();
/*第7步：关闭服务*/
	ser.shutdownNow();
4.2 代码实现：
import java.util.concurrent.*;
/*第1步：实现Callable接口*/
public class C03_CreatThreadMethod_03Callable implements Callable {
    /*第2步：重写call()方法，需要抛出异常*/
    @Override
    public Boolean call() throws Exception {
        System.out.println("多线程开始了");
        for(int i = 0; i <= 100; i ++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
        return true;
    }
    public static void main(String[] args) {
        /*第3步：创建目标对象*/
        C03_CreatThreadMethod_03Callable t1 = new C03_CreatThreadMethod_03Callable();
        C03_CreatThreadMethod_03Callable t2 = new C03_CreatThreadMethod_03Callable();
        /*第4步：创建执行服务*/
        ExecutorService ser = Executors.newFixedThreadPool(2);
        /*第5步：提交执行*/
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        /*第6步：获取结果：*/
        try {
            /*经过测试可知，下面的get()才在底层调用了call()方法，让其执行，并获取到了返回值*/
            boolean r1 = result1.get();
            boolean r2 = result2.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally {
            /*第7步：关闭服务*/
            ser.shutdownNow();
        }
    }
}
五、静态代理简述

实现一个需求，来体验静态代理的作用;

需求：某人要结婚，但是结婚找了婚庆公司代办。简而言之，婚庆公司就是一个代理了。

public class C04_StaticDaiLi {
    public static void main(String[] args) {
        /*我们在测试类中，让某个人结婚*/
        MayyrPerson person = new MayyrPerson("WanLi");
        /*创建婚庆公司对象，让他代理WanLi的结婚事宜*/
        MarryCompany company = new MarryCompany(person);
        company.marry();
    }
}
/*创建结婚接口*/
interface Marry{
    void marry();
}
/*创建即将结婚的人的类，显然这个类要去实现Marry接口*/
class MayyrPerson implements Marry{
    private String name;
    public MayyrPerson() {
    }
    public MayyrPerson(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void marry() {
        System.out.println(name + "结婚中。。。。。很开心！");
    }
}
/*创建婚庆公司的类，这个类也去实现结婚接口，婚庆公司就是一个代理*/
class MarryCompany implements Marry{
    private MayyrPerson person;
    public MarryCompany() {
    }
    public MarryCompany(MayyrPerson person) {
        this.person = person;
    }
    @Override
    public void marry() {
        before();
        person.marry();
        after();
    }
    private void after() {
        System.out.println("正在准备" + person.getName() + "婚后事宜！");
    }
    private void before() {
        System.out.println("正在准备" + person.getName() + "结婚前事宜!");
    }
}

这样做的好处是，代理对象可以做很多真实对象不用做的事情，真实对象只用专注于做自己该做的事情就可以了。这其实就是线程的第二种实现方式的底层原理！

第三节-Lambda表达式
一、概念
  • Functional Interface（函数式接口）：任何接口，如果只包含一个抽象方法，那么它就是一个函数式接口；例如：
interface Runnable{
	void m1();
}
  • 那么针对这样的函数式接口，我们可以使用Lambda表达式来创建该接口的对象；
二、Lambda表达式的使用

使用Lambda表达式的前提是，目标接口必须是一个函数式接口。

2.1 Lambda表达式的语法格式：
接口名 引用名 = () -> {
    方法体;
};//一定不要忘记这里的分号

注意，以上是为了简化函数式接口所做的操作，它的含义是：创建了一个实现了某接口的对象，这个对象调用了接口中唯一的那个方法。例如：

AInterface quote = () -> 
    System.out.println("06-I am a Lambda Expression!-Lambda表达式！");
2.2 有关Lambda表达式的简化
  1. 当Lambda表达式中方法体只有一行代码时，大括号可以省略；
  2. 当目标接口的方法体中有形参时，在Lambda表达式的括号里面可以写上参数类型，也可以选择不写，与参数个数无关；多个参数时，要么把参数类型都去掉，要么都不去掉。
2.3 一个案例搞懂内部类、Lambda表达式的创建对象方式
public class C01_LamdaTest {
    
    /*Ⅱ-静态内部类，去实现函数式接口*/
    static class InternalClass02 implements AInterface{
        /*重写method方法*/
        @Override
        public void method() {
            System.out.println("02-I am a Static Internal Class!-静态内部类");
        }
    }
    /*Ⅲ-非静态内部类*/
    class InternalClass03 implements AInterface{
        @Override
        public void method() {
            System.out.println("03-I am a NullStatic Internal Class!-非静态内部类！");
        }
    }
    public static void main(String[] args) {

        /*Ⅳ-局部内部类*/
        class InternalClass04 implements AInterface{
            /*重写method方法*/
            @Override
            public void method() {
                System.out.println("03-I am a Portion Internal Class!-局部内部类");
            }
        }

        /*01-首先新建外部类对象，调用method()方法*/
        ExternalClass00 ex00 = new ExternalClass00();
        ex00.method();
        
        /*02-创建静态内部类的对象，调用method()方法*/
        InternalClass02 ic02 = new InternalClass02();
        ic02.method();

        /*03-实例内部类,这里需要注意非静态内部类必须要由本类对象去实例化*/
        InternalClass03 ico3 = new C01_LamdaTest().new InternalClass03();
        ico3.method();

        /*04-创建局部内部类对象，调用method()方法*/
        InternalClass04 ic04 = new InternalClass04();
        ic04.method();

        /*Ⅴ-05-匿名内部类，直接利用接口创建对象，创建之后写类体*/
        AInterface ac = new AInterface() {
            @Override
            public void method() {
                System.out.println("05-I am a Anonymous Internal Class!-匿名内部类");
            }
        };
        ac.method();

        /*Ⅵ-06-Lambda表达式，简化以上的操作,JDK1.8的新特性*/
        AInterface lc = () -> {
            System.out.println("06-I am a Lambda Expression!-Lambda表达式！");
        };
        lc.method();
    }
}

/*声明一个函数式接口*/
interface AInterface{
    void method();
}

/*Ⅰ-外部类，实现AInterface接口*/
class ExternalClass00 implements AInterface{
    @Override
    public void method() {
        System.out.println("01-I am a External Class!-普通外部类");
    }
}
第四节-线程的生命周期
一、线程的五大状态
  • 新建状态：当一个线程对象被创建，就代表线程进入了新建状态；
  • 就绪状态：某个线程对象调用了start()方法；
  • 运行状态：某个线程的run()方法开始执行；
  • 阻塞状态：当使用某些方法或者同步锁时，使线程阻塞；
  • 死亡状态：当线程对象的run()方法弹栈后，就代表此线程已死亡。
二、图解线程生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rwDwKOBO-1588519797424)(D:\MyFiles\Markdown\Image\image-20200503204108011.png)]

注意：一个线程对象，不能被启动两次，一旦线程处于死亡状态，该线程就无法使用了，应该是被回收了。

三、线程中的常用方法
3.1 停止线程的做法
  1. 建议让线程自然停止，或者利用次数，避免在线程中使用死循环；
  2. 建议使用标记，利用标记停止线程；
  3. 不要使用stop()/destroy()等已经过时的方法；

代码演示

public class C02_StopAThread implements Runnable{
    /*在类中定义一个标记*/
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        //利用标记来结束这个循环
        while (flag){
            System.out.println(Thread.currentThread().getName() + "---->正在运行" + i++);
        }
        System.out.println(Thread.currentThread().getName() + "已经结束了！" + "此时i的值为：" + i);
    }
    //主方法
    public static void main(String[] args) {
        C02_StopAThread css = new C02_StopAThread();
        Thread cs = new Thread(css, "分支线程1");
        cs.start();
        for (int i = 0; i <= 1000; i++) {
            //设定条件，当i=998的时候，让分支线程停止;
            if(i == 998){
                css.stop();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
    /*通过在外部自定义一个stop方法，来改变flag标记的值，让分支线程停止！*/
    private void stop() {
        this.flag = false;
    }
}
3.2 线程休眠sleep()
  1. Thread.sleep(毫秒数)；可以让当前线程阻塞一定的毫秒数，再进入就绪状态；
  2. 该方法存在异常InterruptedException;
  3. 每个对象都有一个锁，sleep()方法并不会释放锁；
  4. sleep()可以用来模拟网络延迟，倒计时等；

模拟倒计时：

public class C03_TimeCountDown implements Runnable {
    @Override
    public void run() {
        int i = 10;
        while (i >= 0){
            try {
                Thread.sleep(1000);
                System.out.println(i --);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Thread tt = new Thread(new C03_TimeCountDown());
        tt.start();
    }
}
3.3 线程礼让方法yield()
  1. 是Thread类中的一个静态方法，Thread.yield();可以让当前正在执行的线程转为就绪状态，重新参与时间片的抢夺；
  2. 由于是进入了就绪状态，因此该线程有可能继续抢到了时间片，又开始运行。
3.4 join()方法
  1. 是Thread类中的一个实例方法，合并线程，待此线程执行完后，再执行其他线程，此时其他线程进入阻塞状态；
  2. 想象成插队。

代码演示：

public class C04_JoinTest implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
	//主方法
    public static void main(String[] args) {
        Thread tt = new Thread(new C04_JoinTest());
        tt.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + i);
            if(i == 50){
                try {
                    tt.join();//此时，主线程被迫进入阻塞状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
3.5 获取线程的状态getState()
  1. 线程的状态有以下六种情况：NEW, RUNNABLE, BLOCKED, WAATTING, TIMED_WATTING, TERMINATED
  2. 可以使用Thread类中实例方法getState()来获取线程的状态。
3.6 改变线程的优先级
  1. 在Java中提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定给不同线程分配不同的调度概率；
  2. 线程的优先级用数字表示，范围从1-10；

Thread.MIN_PRIORITY = 1;

Thread.MAX_PRIORITY = 10;

Thread.NORM_PRIORITY = 5;

  • 可以使用下列方法，改变线程的优先级：

getPriority().setPriority(int x);

但是要注意：

  • 虽然可以把线程的优先级设置到最高10，但是该线程就不一定会先执行，与该线程是否抢夺到时间片有关，但是一般是线程优先级高的先执行。
  • 当要设置某个线程的优先级时，设置优先级的操作一定是在线程启动之前完成的。
3.７ 守护线程
  1. 线程分为用户线程和守护线程；
  2. 虚拟机需要确保用户线程执行完毕，可以不等待守护线程执行完毕；
  3. 常见的守护线程类型：后台操作日志、监控内存、垃圾回收等．．．．．．
  4. 将某个线程设置为守护线程需要调用Thread类中setDaemon(boolean x)方法,x默认值为false,表示用户线程，设置为true，表示守护线程，同样需要在线程启动之前就设置好。
酸角汁
关注
专栏目录
linux 多线程 信号
yangruibao的专栏
10-28 1997
在开发linux mjpg-streamer程序的时候，使用signal，奇怪的是程序竟然退出了。后来读了曹老师的文章，才解决了这个问题。 所以收录到自己的博客里。呵呵 多线程中定时器的使用41865100619 2010-10-14 19:47:29                                                             ——
异步编程举例之多线程版本闹钟
Pou光明的博客
05-11 642
现在让我们看一个和多进程版本相似的闹钟程序，但它是用多线程实现的。该例子中用到的三个Pthreads函数： ●pthread_create : 创建一个线程，运行由第三个参数(alarm_thread)指定的例程(具体见下面例子)，并返回线程标识符ID(保存在thread引用的变量中) ●pthread_detach : 当线程终止时立刻回收线程资源 ●pthread_exit: ...
c语言中定时执行线程alarm,用多线程写一个alarm，
weixin_36259438的博客
05-22 665
已结贴√问题点数：20回复次数：3 用多线程写一个alarm，#include #include #include #include "errors.h"#define DEBUGusing namespace std;typedef struct alarm_tag{struct alarm_tag *link;int seconds;time_t time;//second...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Qt界面多线程opencv调用摄像头
05-09
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论...
linux 多线程中定时器的使用
热门推荐
ljq1203的专栏
04-01 1万+
在开发linux mjpg-streamer程序的时候，使用signal，奇怪的是程序竟然退出了。后来读了曹老师的文章，才解决了这个问题。 所以收录到自己的博客里。呵呵 多线程中定时器的使用41865100619 2010-10-14 19:47:29                                                             —— 曹忠明
linux进程线程-alarm闹钟函数
小吕的博客
04-22 815
1、alarm 返回值 距离上一次闹钟出发剩余秒数第一次设置返回0，第二次设置了返回距离上一个闹钟的剩余的秒数。 [1] 引用头文件：#include <unistd.h>; [2] 函数标准式：unsigned int alarm(unsigned int seconds); [3] 功能与作用：alarm()函数的主要功能是设置信号传送闹钟，即用来设置信号SIGALRM在经...
多线程环境下定时器存在的问题
崔行兵的专栏
11-20 1364
主要注意pause函数、sleep函数及alarm函数。alarm函数不影响工作线程，只影响主线程。sleep函数让主线程休眠。pause挂起工作线程   #include #include #include #include #include void sig_handler(int signo) {         pthread_t pid=pthread_sel
linux下socket connect 阻塞方式 阻塞时间控制
tinyhare的专栏
09-04 1659
同事今天问我，如何在linux下的c代码里面控制connect的阻塞时间。应用的背景是：linux下的c程序有两个目标IP需要connect，如果用阻塞方式，当其中一个IP不能连接的情况下，程序将阻塞在connect函数上。      本来以为用setsockopt修改个什么参数就可以搞定，结果baidu了半天也没有结果。倒是在网上搜到很多这样的解决方案：将connect方式设置为非阻塞方式，这
AlarmManager-系统推荐的定时任务
朱利源的博客
12-16 1万+
近期leader提了很多这样的需求：每隔几个小时拉取服务器的配置信息存在本地、每隔一段时间跟服务端校对一下本地时间、每隔一段时间上传一下本地日志等等。其实这些本质都是定时任务，隔一段时间去干xxx，那么在安卓中定时任务无非三种实现方式，Handler(CountDownTimer)、Timer、while循环、AlarmManager。（如果有遗漏还望留言告知O(∩_∩)O谢谢）前三种大家基本都用过
alarm
码农崛起
12-15 702
相关函数：signal, sleep 头文件：#include 定义函数：unsigned int alarm(unsigned int seconds); 函数说明：alarm()用来设置信号SIGALRM 在经过参数seconds 指定的秒数后传送给目前的进程. 如果参数seconds 为0, 则之前设置的闹钟会被取消, 并将剩下的时间返回. 返回值：返回之前闹钟的剩
C++ 多线程计时的bug，千万别用clock()
hqh45的专栏
03-22 1万+
最近在做多线程编程，没有那么牛的使用pthread直接多线程，是对当前的算法进行优化，所以尝试了一下openmp和intel的tbb,结果发现都比原来还慢，由此引发了持续三天的debug..... 最后在使用tbb的时候发现tbb有一个自带的计时函数，调用了一下，发现比clock()函数出来的时间要快好多，上stackoverflow，，，果然有bug。 clock() measure t
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值