java学习笔记10——多线程的学习

最新推荐文章于 2021-10-12 23:29:00 发布
最新推荐文章于 2021-10-12 23:29:00 发布
阅读量251 收藏
点赞数 1
分类专栏： java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010935199/article/details/70053277
版权
这一段主要写一下关于java多线程的一些知识。这里仅仅简单的介绍一下，java多线程一直是编程的重点，有很多知识点讲都讲不完，需要很深入的学习和总结。

一、线程和进程

这里摘抄一下概念：

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。
线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。

  上述概念其实也就是一个大概，可以很抽象的理解，大家有没有见过网线，一根网线里面有8根颜色不同的铜丝，这里就可以把里面的8根理解成线程，而那根网线就是一个进程，是一个包含的关系。
  多线程就是在宏观上具有不止一个线程在程序中运行。这里需要注意，这里我们以单核处理器为依据，在宏观时间上来分析，如果是微观时间上，那么还是一个个进程来处理的，就看谁可以抢到运行资源了。大家看图：
这里写图片描述
横着表示多线程，并发
斜线表示多进程，并行
  这里如果要深入理解的话，建议大家可以去看一下操作系统的书，里面讲的很详细，这里不做叙述。

二、实现多线程

在java中，实现多线程主要有两种方法，一种，继承Thread类，还有一种是实现runable接口

1、继承Thread类

继承Thread类，然后重写其中的run()方法。

public class ThreadDemo extends Thread {
  private String name;
  public ThreadDemo(String name) {
    this.name = name;
  }

  public void run() {
    for (int i = 0; i < 5; i++) {
      System.out.println(name + "线程" + i);
      try {
        sleep(100); //不让当前线程一直霸占资源
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

public class Test {
  public static void main(String[] args) {
    ThreadDemo threadDemo1 = new ThreadDemo("A");
    ThreadDemo threadDemo2 = new ThreadDemo("B");
    threadDemo1.start();
    threadDemo2.start();
  }
}

运行结果：

A线程0
B线程0
A线程1
B线程1
A线程2
B线程2
A线程3
B线程3
A线程4
B线程4

  大家看，这里建立了两个线程，然后对其进行start()操作，就是让线程就绪，当抢占到资源的时候就会开始运行。看输出结果也是A和B穿插着的，这就是谁抢到资源就会谁运行。

2、实现runable接口

实现runable接口，实现run()方法。

public class RunableDemo implements Runnable {

  private String name;
  public RunableDemo(String name) {
    this.name = name;
  }

  @Override
  public void run() {
    for (int i = 0; i < 5; i++) {
      System.out.println(name + "线程" + i);
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

public class RunableTest {
  public static void main(String[] args) {
    RunableDemo runableDemo1 = new RunableDemo("C");
    RunableDemo runableDemo2 = new RunableDemo("D");
    new Thread(runableDemo1).start();
    new Thread(runableDemo2).start();
  }
}

结果：

C线程0
D线程0
D线程1
C线程1
C线程2
D线程2
D线程3
C线程3
D线程4
C线程4

  这也是一种实现多线程的方法。在这里需要注意，在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

三、thread和runable的区别

这里看两个例子：

public class ThreadDemo extends Thread {

  private String name;
  private int count = 10;

  public ThreadDemo(String name) {
    this.name = name;
  }

  public void run() {
    for (int i = 0; i < 5; i++) {
      System.out.println(count--);
      try {
        sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

public class Test {
  public static void main(String[] args) {
    ThreadDemo threadDemo1 = new ThreadDemo("A");
    ThreadDemo threadDemo2 = threadDemo1;
    threadDemo1.start();
    threadDemo2.start();
  }
}

结果：

Exception in thread "main" 10
java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Thread.java:705)
    at com.songqijie.demo.thread.Test.main(Test.java:28)
9
8
7
6

用runable来实现：

public class RunableDemo implements Runnable {

  private String name;
  private int count = 10;

  public RunableDemo(String name) {
    this.name = name;
  }

  @Override
  public void run() {
    for (int i = 0; i < 5; i++) {
      System.out.println(name + "线程" + (count--));
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

public class RunableTest {
  public static void main(String[] args) {
    RunableDemo runableDemo1 = new RunableDemo("C");
    RunableDemo runableDemo2 = runableDemo1;
    new Thread(runableDemo1).start();
    new Thread(runableDemo2).start();
  }
}

运行结果：

C线程10
C线程9
C线程8
C线程7
C线程6
C线程5
C线程4
C线程3
C线程2
C线程1

  可见，对于相同的一个实例，使用runable接口可以生成多个线程运行，而Thread相当于对相同的线程进行操作，这样就报错了，这里如果是一个购票系统或者其他的有固定的数量的系统，那么肯定还是runable更加的安全和实用。
可见，runable实现多线程更具有优势
1. 适合多个相同的程序代码的线程去处理同一个资源
2. 可以避免java中的单继承的限制
3. 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

四、线程中的一些常用方法

线程分为5个阶段：新建，就绪，运行，阻塞，死亡。
这里写图片描述
1. 在线程中，可以设置其优先级，优先级高的线程可以获得较多的运行资源。
- Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：
- static int MAX_PRIORITY
线程可以具有的最高优先级，取值为10。
- static int MIN_PRIORITY
线程可以具有的最低优先级，取值为1。
- static int NORM_PRIORITY
分配给线程的默认优先级，取值为5。
  Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。
每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。
  线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。
  JVM提供了10个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用Thread类有以下三个静态常量作为优先级，这样能保证同样的优先级采用了同样的调度方式。
2. sleep(long millis)：
指在制定的时间内让线程进行休眠，也就是暂停执行操作
3. join()：
join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。
看下面的代码：
不加join()：

public class ThreadDemo extends Thread {

  private String name;
  private int count = 10;

  public ThreadDemo(String name) {
    this.name = name;
  }

  public void run() {
    for (int i = 0; i < 5; i++) {
      System.out.println(name + "线程" + count--);
      try {
        sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}
public class Test {
  public static void main(String[] args) {
    System.out.println("主线程开始");
    ThreadDemo threadDemo1 = new ThreadDemo("A");
    ThreadDemo threadDemo2 = new ThreadDemo("B");
    threadDemo1.start();
    threadDemo2.start();
    System.out.println("主线程结束");
  }
}

运行结果：

主线程开始
主线程结束
A线程10
B线程10
B线程9
A线程9
B线程8
A线程8
A线程7
B线程7
B线程6
A线程6

加join()：这里只修改test类

public class Test {
  public static void main(String[] args) {
    System.out.println("主线程开始");
    ThreadDemo threadDemo1 = new ThreadDemo("A");
    ThreadDemo threadDemo2 = new ThreadDemo("B");
    threadDemo1.start();
    threadDemo2.start();
    try {
      threadDemo1.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    try {
      threadDemo2.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("主线程结束");
  }
}

运行结果：

主线程开始
A线程10
B线程10
A线程9
B线程9
A线程8
B线程8
B线程7
A线程7
A线程6
B线程6
主线程结束

  可以发现，加了join，主线程会等待join的结束再运行，而不是和join的线程增多资源。
这里需要注意！join之前需要先把线程start(),而不能先join再start
4. yield()：
  Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
  yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
  yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。可看上面的图。

sleep()和yield()的区别

  sleep()和yield()的区别):sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
   sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
   另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield() 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。
5. interrupt()：
  中断某个线程，这种结束方式比较粗暴，如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程，会导致资源无法关闭
6. wait()
  Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){…}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

五、线程同步

这里首先需要说一下关于线程安全的概念：
线程安全：
  当多个线程类并发操作某类的某个方法，(在该方法内部)来修改这个类的某个成员变量的值，不会出错，则我们就说，该的这个方法是线程安全的。
某类的某方法是否线程安全的关键是：
- 该方法是否修改该类的成员变量;
- 是否给该方法加锁(是否用synchronized关键字修饰）。
线程不安全：
　　当多个线程类并发操作某类的某个方法，(在该方法内部)来修改这个类的某个成员变量的值，很容易就会发生错误，故我们就说，这个方法是线程不安全的。如果要把这个方法变成线程安全的，则用 synchronized关键字来修饰该方法即可。
　　注：用 synchronized关键字修饰方法，会导致加锁，虽然可以使该方法线程安全，但是会极大的降低该方法的执行效率，故要慎用该关键字。
　　
1. synchronized关键字的作用域有二种：

  • 是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
  • 是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2.除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/区块/}，它的作用域是当前对象；

3.synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

  总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。
在进一步阐述之前，我们需要明确几点：
A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
B．每个对象只有一个锁（lock）与之相关联。
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

这里举一个例子：
不加synchronized：

public class ThreadDemo extends Thread {
  public static void main(String[] args) {
    HasSelfPrivateNum numRef = new HasSelfPrivateNum();
    ThreadA athread = new ThreadA(numRef);
    athread.start();
    ThreadB bthread = new ThreadB(numRef);
    bthread.start();
  }
}

class HasSelfPrivateNum {
  private int num = 0;
  public void addI(String username) {
    try {
      if (username.equals("a")) {
        num = 100;
        System.out.println("a set over!");
        Thread.sleep(2000);
      } else {
        num = 200;
        System.out.println("b set over!");
      }
      System.out.println(username + " num=" + num);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

class ThreadA extends Thread {
  private HasSelfPrivateNum numRef;
  public ThreadA(HasSelfPrivateNum numRef) {
    super();
    this.numRef = numRef;
  }

  @Override
  public void run() {
    super.run();
    numRef.addI("a");
  }
}

class ThreadB extends Thread {
  private HasSelfPrivateNum numRef;
  public ThreadB(HasSelfPrivateNum numRef) {
    super();
    this.numRef = numRef;
  }

  @Override
  public void run() {
    super.run();
    numRef.addI("b");
  }
}

运行结果：

a set over!
b set over!
b num=200
a num=200

加了synchronized：只修改一下部分：

synchronized public void addI(String username) {
    try {
      if (username.equals("a")) {
        num = 100;
        System.out.println("a set over!");
        Thread.sleep(2000);
      } else {
        num = 200;
        System.out.println("b set over!");
      }
      System.out.println(username + " num=" + num);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

运行结果：

a set over!
a num=100
b set over!
b num=200

  从运行结果可以发现，加了锁和没加锁是不通的，加了锁以后就编程线程安全了，不会进行资源的互相争抢。
  线程锁博大精深，这里我也就说了一个大概，大家有兴趣可以去买本java多线程编程看看。

参考资料：

http://blog.csdn.net/gf771115/article/details/51682561
http://www.importnew.com/20444.html

SongQijie
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA学习笔记————————
04-25
在深入探讨JAVA学习笔记之前，我们首先理解一下JAVA这一编程语言的重要性。JAVA，由Sun Microsystems公司（现已被Oracle收购）于1995年推出，是一种面向对象的、跨平台的编程语言，以其“一次编写，到处运行”的特性...
个人学习的java笔记——思维导图
01-25
这份"个人学习的java笔记——思维导图"涵盖了上述诸多Java编程的核心知识点，通过思维导图的方式，使得学习者可以更直观地理解和记忆这些复杂的概念，对提升Java学习效果大有裨益。无论你是初学者还是有经验的开发者...
java——第十章 多线程
weixin_44086467的博客
12-23 195
10.1 进程：在一个操作系统中，每个独立执行的程序都可称为一个进程 进程的基本特征：1、进程是可用于资源的独立单位 2、进程同时是一个可独立调度和分派的基本单位 10.2 线程：一段静态代码应用软件执行 线程的基本特征：1、线程是进程的所有特征，被称为轻量级进程 2、线程是进程的实体 3、线程不拥有系统资源 4、线程可以创建撤销 10.2.1 线程的创建 Thread 类实现多线程 （1）创建一...
java--第10章 多线程
北山啦的博客
01-09 2791
实验目的： 1.理解解线程的概念及线程的生命周期。 2.掌握多线程的编程。 实验内容： 1.通过继承Thread类创建线程。 2.通过实现Runnable接口创建线程。 3.线程优先级操作。 4.用两个线程玩猜数字的游戏。 实验步骤： 1.通过继承Thread类创建一个实现睡眠(时间在1～5秒)功能的线程，显示它的睡眠时间及其线程名称。 源代码： package homework.实验10_多线程...
java学习笔记————多线程
weixin_46141002的博客
09-09 118
多线程 （java） 1、进程和线程2、使用多线程3、实例变量与线程安全4、多线程方法 1、进程和线程 一个程序就是一个进程，而一个程序中的多个任务则被称为线程。 进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。 线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元。 1.进程是操作系统分配资源的最小单位，线程是程序执行的最小单位。 2.一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；
Java之多线程学习笔记五 —— 多线程模拟龟兔赛跑
影龙武的博客qq_43594119
05-04 293
Java之多线程学习笔记五 —— 多线程模拟龟兔赛跑 package pers.ylw.lesson01; //模拟龟兔赛跑 public class Race implements Runnable{ //胜利者 private static String winner; @Override public void run() { for ...
Java学习笔记十七——集合类详细总结各自对比
Pandafz的博客
10-12 3839
一、Java集合介绍
JAVA学习笔记（多线程一）——多线程的概念
m0_46450708的博客
07-19 149
JAVA学习笔记——多线程（一） （程序，进程，线程）概念 1.程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 2.进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期 比如:运行中的QQ，运行中的360 注意：程序是静态的，进程是动态的（两者的区别） 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 3.线程(thead)，进程可进一步细化为线程，是一个
Java之多线程学习笔记十 —— 线程休眠
影龙武的博客qq_43594119
05-05 204
Java之多线程学习笔记十 —— 线程休眠 线程休眠的应用 package pers.ylw.state; import java.text.SimpleDateFormat; import java.util.Date; public class TestSleep2 { public static void main(String[] args) { //ten...
Java之多线程学习笔记十一 —— 线程礼让yield
影龙武的博客qq_43594119
05-05 225
Java之多线程学习笔记十一 —— 线程礼让yield yield 礼让测试 package pers.ylw.state; //测试礼让线程 //礼让不一定成功，只是让线程重新竞争资源，看CPU心情 public class TestYield { public static void main(String[] args) { MyYield myYield = ...
Java学习笔记9——多线程
xiaoyao3857的专栏
10-07 1943
从《UNIX环境高级编程》知，多线程这个概念出现不是很久，作为现代IT的发展，面向对象的编程语言不可能不支持多线程。 所谓的多线程，可以简单的理解为同一个时段，有多个子任务"同时"运行，但要注意其与多进程的区别——或者最重要的一点，要牢记多进程比多线程切换的开销小得多。     多线程是指同时存在几个执行体，按几条不同的执行线索共同工作的情况。Java语言实现了对多线程的支持，它使得编程人员可
Java之多线程学习笔记十八 —— CopyOnWriteArrayList
影龙武的博客qq_43594119
05-06 157
Java之多线程学习笔记十八 —— CopyOnWriteArrayList CopyOnWriteArrayList JUC里线程安全的集合 package pers.ylw.syn; import java.util.concurrent.CopyOnWriteArrayList; //测试JUC安全类型的集合 public class TestJUC { public stat...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java学习笔记——良葛格
06-12
"Java学习笔记——良葛格"是一份专为初学者设计的教程资料，由良葛格精心编写，旨在帮助读者掌握JDK5.0版本的Java基础知识。JDK（Java Development Kit）是Java开发的核心工具集，包含了编译器、调试器和运行环境等...
java多线程学习笔记02（csdn）————程序.pdf
12-01
在这个学习笔记中，主要讨论了Java中的线程同步机制，包括volatile关键字、synchronized以及Lock接口，特别是ReentrantLock的使用。 首先，对于线程1和线程2的疑惑，调试（debug）模式并不能改变线程的执行顺序。...
java学习笔记5——对象以及包，类和方法
SongQijie的博客
04-01 866
这部分对java面向对象的实现进行一个大致的说明。
java web开发——session简介
SongQijie的博客
06-30 727
因为一直做的都是java后端，对于这些偏前端的知识有点模糊，昨天面试的时候被问到session的工作原理，一脸懵逼，今天整理一下。
java学习笔记6——封装、继承和多态
SongQijie的博客
04-05 638
java是一种面出现对象的编程语言，他的三个最重要的特性就是封装，继承和多态。这里大致介绍一下，有个了解，想要详细学习的可以去查看一下《think in java》这本书，或者上网学习。
java学习笔记14——JDBC深入
SongQijie的博客
04-19 569
上一章讲了java最基础的jdbc的操作，这里加深一下。
JAVA学习笔记整理(全)
06-03
目录 JAVA 1 一、 基础语法 1 二、 MYSQL 33 三、 Nginx 60 四、 Redis 67 五、 Mybatis 75 六、 Spring 77 七、 Docker 84 八、 计算机网络 86 九、 JVM 96 十、 Springboot 111 十一、 RabbitMQ 112 十二、 其它 115 十三、 操作系统 126 十四、 数据结构 133 十五、Linux 133

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值