Java多线程总结：进程与线程、线程的创建、线程状态与分类、线程方法、线程同步

已于 2022-11-15 12:33:22 修改
阅读量492 收藏 1
点赞数 1
分类专栏： 学习笔记 Java 文章标签： java 算法 数据结构 多线程 生产者消费者
于 2022-11-15 12:19:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53130059/article/details/127703441
版权

文章目录

一、进程（Process）与线程（Thread）

说的进程，先来提一下程序的概念：程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态概念。
进程：进程是程序执行一次的过程，是一个动态概念，同时也是系统资源分配的基本单位。
线程：线程是一个独立执行的路径，它包含在进程之中，通常情况下一个进程可以包含若干个线程，我们熟知的main就是一个主线程，当然一个进程中至少有一个线程，不然它就没有存在的意义了，线程是CPU调度的基本单位。
再说说多线程，其实很多多线程都是模拟出来的，真正情况下的多线程是有多个CPU的，例如服务器等等，而 模拟出来的多线程，其实是在一个CPU的情况下，在同一时间点，CPU只能执行一个代码，但因为切换速度快，所以产生了同时执行的错觉。

相关知识：
1.程序运行时，即使自己没有创建线程，后台也会有多个线程，例如主线程main，垃圾回收线程gc等。
2.main()为主线程，是系统的入口，用于执行整个程序。
3.我们对同一份资源进行操作时，会存在资源抢夺问题，需要加入并发控制。
4.每个线程在自己的工作内存交互，内存控制不当会导致数据不一致。

二、线程的创建

创建方式：
继承Thread类
实现Runnable接口
实现Callable接口

1.继承Thread类

Thread实现了Runnable接口，要通过继承Thread类实现多线程，需要 分三步：
1.自定义线程类继承Thread类；
2.重写run()方法，编写线程执行体；
3.创建线程对象，调用start()方法启动线程。

代码示例：

//创建线程方式 继承Thread类

public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("看电视" + i);
        }
    }

    public static void main(String[] args) {

        //创建线程对象
        TestThread1 t1 = new TestThread1();
        //start方法开启线程
//        t1.run();
        t1.start();

        //main线程
        for (int i = 0; i < 500; i++) {
            System.out.println("我在玩游戏" + i);
        }
    }
}

结果：

在这里插入图片描述

我们可以知道，当我们直接调用t1.run()时，run方法因为没有并发性，所以会先执行run方法再执行for循环，而当我们通过t1.start()启动线程时，就会出现上述图片结果，两个线程交替执行，一般来说是t1线程比主线程慢，因为start()启动线程需要时间。调用run和start的区别可以参考下图：

在这里插入图片描述

2.实现Runnable接口

该方法需要 分三步：
1.定义MyRunnable类实现Runnable接口；
2.实现run()方法，编写线程执行体；
3.创建线程对象，调用start()方法启动线程。

代码示例：

//创建线程方式2 实现接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("看电视" + i);
        }
    }

    public static void main(String[] args) {

        //创建线程对象
        MyRunnable t = new MyRunnable();
        new Thread(t).start();
        
        //main线程
        for (int i = 0; i < 500; i++) {
            System.out.println("我在玩游戏" + i);
        }
    }
}

二者比较：
继承Thread类：不建议使用，有单继承局限性，如果使用了就不能继承其他类了。
实现Runnabke类：推荐使用，避免了单继承局限性，灵活方便，方便同一个对象被多个线程使用。

一个对象被多个线程使用图示：
在这里插入图片描述

一个对象被多个线程使用代码示例：买火车票案例，该案例里面是有错误的，线程会抢夺相同的资源，大家运行一下就知道了，后续会说：


//多个线程同时操作一个对象
//买火车票例子

public class TestThread3 implements Runnable{

    private int ticket = 20;

    @Override
    public void run() {
        while (true){
            if (ticket <= 0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //Thread.currentThread().getName()获取当前线程的调用者
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticket-- + "张票");
        }
    }

    public static void main(String[] args) {
        TestThread3 t = new TestThread3();

        new Thread(t,"小菜").start();
        new Thread(t,"小许").start();
        new Thread(t,"小困").start();
    }
}

3.实现Callable接口

该方法（暂时了解即可，后续可能会补充）需要 步骤为：
1.实现Callable接口，需要返回值类型；
2.重写call方法，需要抛出异常；
3.创建目标对象；
4.创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5.提交执行：Future result1 = ser.submit(t1);
6.获取结果：boolean r1 = result1.get();
7.关闭服务：ser.shutdownNow()。

三、线程的状态和分类

1.线程的状态

线程的五个状态及其转化图：
在这里插入图片描述

线程状态。 线程可以处于以下状态之一：
NEW ：尚未启动的线程处于此状态。
RUNNABLE ：在Java虚拟机中执行的线程处于此状态。
BLOCKED ：被阻塞等待监视器锁定的线程处于此状态。
WAITING ：正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING ：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED ：已退出的线程处于此状态。
PS：线程不能启动两次

2.线程的分类

线程可以分为 用户线程和守护线程，虚拟机必须保证用户线程执行完毕，不用等待守护线程执行完毕，守护线程诸如后台操作日志、监控内存、垃圾回收线程gc等等。

四、线程的方法

线程的常用方法：

在这里插入图片描述

1.线程的停止

代码示例：

//测试stop

//1.建议线程正常停止 利用次数 不建议死循环
//2.建议使用标志位 设置一个标志位
//不要使用stop或者destroy等过时或者JDK不建议使用的方法

public class TestStop implements Runnable {

    //设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("Thread : " + i++);
        }
    }

    //设置一个公开的方法停止线程
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop t = new TestStop();
        new Thread(t).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main : " + i);
            if (i == 900) {
                t.stop();
                System.out.println("线程该停止了！");
            }
        }
    }
}

2.线程的休眠

使用sleep函数，该函数以ms为单位。同时需要知道：每个对象都有一把锁，sleep不会释放锁。

代码示例：

//模拟倒计时

public class TestSleep_1 {

    public static void main(String[] args) {
        tenDown();
    }

    public static void tenDown() {
        int num = 10;
        while (true) {
            //延时1s 每秒输出一次
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num--);
            if (num == 0) {
                break;
            }
        }
    }
}

3.线程礼让

线程礼让使用yield方法，调用该方法时，让当前正在执行的线程暂停，但不进入阻塞状态，而是重新变为就绪状态，让CPU重新调度，所以说，线程礼让是不一定会成功的，得看CPU的心情，比如，你调用了yield，下次CPU依旧调度你，这是可能发生的。

4.线程插队

join方法可以使其他线程阻塞，优先执行本线程，本线程执行完在执行其他线程。

代码示例：

//测试join方法 类似插队

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("VIP线程--" + i);
        }
    }

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

        //启动
        TestJoin t = new TestJoin();
        Thread thread = new Thread(t);
        thread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程--" + i);
            if (i == 50) {
                thread.join();
            }
        }
    }
}

五、线程同步

1.线程同步机制、锁机制、死锁

线程同步机制：在多线程问题上，若多个线程访问同一个对象，并且有可能修改这个对象，这时候就需要线程的同步。线程同步其实就是一种等待机制，多个需要同时访问这个对象的线程，进入这个对象的等待池形成队列，等待前面的一个线程使用完毕，下一个线程在继续使用。
线程同步的形成条件需要队列+锁。

锁机制：由于同一个进程的多个线程访问同一个存储空间，带来方便的同时也带来了冲突，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排它锁，独占资源，其他的线程必须等待，使用后释放锁机可。

死锁：死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

2.同步方法和同步块

synchronized方法： public synchronized void method(int args){};
synchronized块： synchroized (ojb){};

区别：
同步方法默认用this或当前类class对象作为锁；同步代码块可以选择以什么来加锁，比同步方法要更细，我们可以选择只同步会发生同步问题的部分代码而不是整个方法；不太理解往这走–synchronized同步方法与同步块

3.简单的买票案例

线程不安全：


//线程不安全的买票案例

public class BuyTickets {
    public static void main(String[] args) {

        BuyTicket b = new BuyTicket();

        new Thread(b, "小菜").start();
        new Thread(b, "小徐").start();
        new Thread(b, "小困").start();
    }
}

class BuyTicket implements Runnable {

    private int tickets = 20;
    boolean flag = true;

    @Override
    public void run() {

        while (flag) {
            try {
                //模拟一下延时
                Thread.sleep(100);
                buyTicket();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void buyTicket() throws InterruptedException {

        if (tickets <= 0) {
            flag = false;
            return;
        }

        System.out.println(Thread.currentThread().getName() + "获得了第" + tickets-- + "张票");
    }
}

synchronized方法：

public class BuyTickets {
    public static void main(String[] args) {

        BuyTicket b = new BuyTicket();

        new Thread(b, "小菜").start();
        new Thread(b, "小徐").start();
        new Thread(b, "小困").start();
    }
}

class BuyTicket implements Runnable {

    private int tickets = 20;
    boolean flag = true;

    @Override
    public void run() {

        while (flag) {
            try {
                //模拟一下延时
                Thread.sleep(100);
                buyTicket();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void buyTicket() throws InterruptedException {

        if (tickets <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "获得了第" + tickets-- + "张票");
    }
}

synchronized同步代码块：

public class BuyTickets {
    public static void main(String[] args) {

        BuyTicket b = new BuyTicket();

        new Thread(b, "小菜").start();
        new Thread(b, "小徐").start();
        new Thread(b, "小困").start();
    }
}

class BuyTicket implements Runnable {

    private int tickets = 20;
    boolean flag = true;

    @Override
    public void run() {

        while (flag) {
            try {
                //模拟一下延时
                Thread.sleep(100);
                buyTicket();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void buyTicket() throws InterruptedException {
        synchronized ((Object) tickets) {
            if (tickets <= 0) {
                flag = false;
                return;
            }
            System.out.println(Thread.currentThread().getName() + "获得了第" + tickets-- + "张票");
        }
    }
}

4.Lock锁

Lock是一个显示锁，需要手动开启手动关闭，不同于synchronized是一个隐式锁（出了作用域自动释放），Lock锁的性能高于synchronized锁，在使用时，选择优先级为：Lock > 同步代码块 > 同步方法。

使用格式：

        //加锁
        lock.lock();
        try {
        //需要保证线程安全的代码
            }
        } finally {
            //解锁
            lock.unlock();
        }

买票案例改：


import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    public static void main(String[] args) {

        Buy b = new Buy();

        new Thread(b, "小菜").start();
        new Thread(b, "小徐").start();
        new Thread(b, "小困").start();
    }
}

class Buy implements Runnable {

    private int tickets = 20;
    //定义锁
    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                //模拟延时
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                //加锁
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + "获得了第" + tickets-- + "张票");
                } finally {
                    //解锁
                    lock.unlock();
                }
                
            } else {
                break;
            }
        }
    }
}

5.线程通信：生产者消费者问题

问题介绍 -> 生产者消费者问题

图示：
在这里插入图片描述

代码实现：

package Synchronized;

public class TestPC {
    public static void main(String[] args) {
        SynContainer c = new SynContainer();
        new Producter(c).start();
        new Consumer(c).start();
    }
}

//缓冲区
class SynContainer {

    private String[] s = new String[10];
    //记录个数
    private int idx = 0;

    //供生产者调用
    public synchronized void push(String str) {
        //缓冲区满了 生产者等待
        if (idx == s.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //没满
        s[idx++] = str;
        //通知消费者可以消费了
        this.notify();
    }

    //供消费者调用
    public synchronized String pop() {
        //如果缓冲区没有产品 消费者等待
        if (idx == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //有产品
        idx--;
        String product = s[idx];
        //通知生产者可以生产了
        this.notify();
        return product;
    }

    public String[] getS() {
        return s;
    }
}

//生产者
class Producter extends Thread {

    private SynContainer container;

    public Producter(SynContainer container) {
        this.container = container;
    }

    public void run() {
        for (int i = 0; i < container.getS().length; i++) {
            String producter = "产品" + i;
            container.push(producter);
            System.out.println("生产了：" + producter);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者
class Consumer extends Thread {

    private SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    public void run() {
        for (int i = 0; i < container.getS().length; i++) {
            String consumer = container.pop();
            System.out.println("消费了：" + consumer);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

六、总结

其实没啥总结，边听课边记录的，感觉深度应该是不太够的，应该只能做做基础，这块好像是面试的重点，后续应该还要重新深入学习。

木木是木木
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java中多线程、并发、并行、线程与进程、线程调度、创建线程的方式
专研前端，探索后端
12-17 945
java中多线程、并发、并行、线程与进程、线程调度、创建线程的方式
【Java 11】多线程 - 程序、进程、线程、线程的创建和使用、线程的生命周期、线程的同步、线程的通信、JDK5.0新增线程创建方式
Wmiao
08-18 284
一 Idea 1 快捷补全 new Method() 使用Alt + Enter 可补全 Method method = new Method()； psvm : 可生成 main 方法 sout : System.out.println() 快捷输出 soutp=System.out.println("方法形参名 = " + 形参名); soutv=System.out.println("变量名 = " + 变量); soutm=System.out.println(“当前类名.当前方法”
Java的多线程基础、创建线程和线程同步
yuDong1109的博客
03-22 254
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。
Java多线程的常见创建方式与区别、以及同步问题
yanghao201607030101的博客
07-30 168
相关概念： 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生（同时发生）。 所谓的并发实质是宏观上同时进行，微观上交替运行，单核处理器同一时刻只能处理一个任务，所以单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。 同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。 多核处理器的系
Java学习笔记（四）：创建多线程的四种方式 & 同步机制
qq_40177015的博客
03-06 210
文章目录基本概念程序（program）进程（process）线程（thread）多线程（multi-thread）优点应用场合生成线程Java同步机制来解决线程安全的问题死锁同步机制同步代码块同步方法Lock（JDK5.0增加）synchronized和Lock的异同点线程通信涉及到的方法：wait() & notify() & notifyAll()sleep() & wait()创建线程的其他方式实现Callable接口（JDK5增加）线程池 基本概念 程序（program） 一
Java开发笔记:多线程基础和同步
Tai_Monster的博客
03-23 208
线程和进程都是操作系统中用来实现并发的基本单位。进程是计算机中的一个程序或任务，它包含了程序代码、数据、寄存器、打开的文件等资源。而线程是进程中的一个执行流程，每个线程都有自己的堆栈、寄存器、程序计数器等资源。线程和进程的关系可以描述为：进程可以包含多个线程。一个进程可以同时执行多个线程，每个线程可以独立地执行不同的任务。多个线程可以共享进程的资源，如内存、文件句柄等。线程的创建和销毁都是由进程控制的。一个进程可以创建多个线程，并在需要时销毁线程。线程的创建和销毁比进程的创建和销毁更快速和灵活。
Java 多线程详解——创建、使用、同步和通信
un357951的博客
11-02 190
基本概念 程序(program): 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process): 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread): 进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一时间并行执行多个线程
Java多线程-线程的安全问题与线程的同步机制介绍
01-29
Java多线程-线程的安全问题与线程的同步机制介绍 在 Java 多线程编程中，线程安全问题是非常重要的一个话题。当多个线程访问同一个资源时，如果只有读操作那么不会出现线程安全问题，但是如果多个线程对资源进行读...
Java多线程 线程同步与死锁
08-30
Java多线程 线程同步与死锁 Java多线程是一种编程技术，允许多个线程同时执行，以提高程序的执行效率和响应速度。但是，多线程编程也存在一些安全问题，例如线程同步和死锁问题。 线程同步是指多个线程之间的协作...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java 线程详解及线程与进程的区别
08-31
Java线程详解与进程的区别是...了解线程与进程的区别以及如何在Java中创建和管理线程，对于开发高效、健壮的多线程应用至关重要。正确地处理线程同步和通信可以避免死锁、活锁和饥饿等问题，确保程序的稳定性和正确性。
Java线程与多线程教程Java开发Java经验技巧共4页
11-25
Java线程与多线程是Java开发中的核心概念，对于任何Java开发者来说，理解和掌握这部分内容至关重要。在Java中，线程是程序执行的基本单元，它允许程序同时执行多个任务，提高了程序的运行效率和响应速度。本教程将...
【Java学习】多线程：线程创建、线程状态、线程同步、线程通信全总结
胡毛毛的博客
11-14 1198
目录1、基本概念2、线程创建2.1、 继承 Thread 类（重点）Thread API2.2、 实现Runnable接口（重点）Runnable接口API以上两种方式的比较：初识并发问题——买火车票龟兔赛跑问题：img2.3、 实现Callable接口（了解）2.4、 Lambda表达式2.5、 静态代理模式img3、线程状态3.1、 线程的一些常用方法常用方法——API3.2、 线程休眠——sleep()sleep——APIimg3.3、 线程礼让——yield()yield()——API3.4、 合并
Java 线程的使用
weixin_53472653的博客
06-02 3276
尚硅谷学习笔记
Java并发编程--多线程间的同步控制和通信
BASK2311的博客
11-24 472
同步控制的一大思路就是加锁，除了本问学习到的 sychronized 同步控制，Java 里还有 JUC 的可重入锁、读写锁这种加锁方式，这个我们后续介绍 JUC 的时候会给大家讲解。另外一种思路是不加锁，让线程和线程之间尽量不要使用共享数据，ThreadLocal 就是这种思路，下篇我们介绍 Java 的线程本地存储 -- ThreadLocal。
Java线程创建与同步
天下英雄谁敌手？曹刘
08-31 317
线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。多线程是指在同一程序中有多个顺序流在执行。 创建多线程的方式一：继承于Thread类 继承Thread类  1)  定义子类继承Thread类。  2)  子类中重写Thread类中的run方法。  3)  创建Thread子类对象，即创建了线程对象。  4)  调用线程对象star
全网最详细并发编程（1）---入门篇
Java技术大联盟
04-23 2540
并发编程 1. 进程与线程 1.1 进程与线程 进程 ●程序由**指令和数据**组成，但这些指令要运行，数据要读写，就必须**将指令加载至 CPU，数据加载至内存**。在指令运行过程中还需要用到磁盘、网络等设备。**进程就是用来加载指令、管理内存、管理 IO 的** ●当一个程序被运行，**从磁盘加载这个程序的代码至内存，这时就开启了一个进程**。 ●**进程就可以视...
Java多线程创建、线程同步、线程通信相关笔记
FrankHu2021的博客
10-20 189
Java多线程创建、线程同步、线程通信相关笔记
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 602
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

木木是木木

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

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

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

打赏作者

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

抵扣说明：

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

余额充值