【Java高级编程】Java多线程学习笔记

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量158 收藏 1
点赞数
分类专栏： # Java高级 文章标签： java 学习 jvm 开发语言 servlet
原创文章谢绝转载！不允许搬运！不授权任何人！
本文链接：https://blog.csdn.net/ks2686/article/details/126527370
版权

Java 多线程

目录

1.多线程创建

方法1：通过 继承 thread 类

[子线程代码] MyThread.java

package example01_thread;

public class MyThread extends Thread {
    @Override
    public void run() {
        // super.run();
        for (int i = 0; i <= 1000; i++) {
            System.out.println("===> 子线程 " + i);
        }
    }
}

[主线程代码] Test.java

package example01_thread;

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        //myThread.run(); //方法调用，单线程。
        myThread.start(); // 启动线程，多线程。 这个.statr() 继承自Thread类
        for (int i = 0; i <= 1000; i++) {
            System.out.println("===> 主线程 " + i);
        }
    }
}

[运行结果]

img.png

方法2：通过 实现 Runnable 接口

[子线程代码] MyRunnable.java

package example02_runnable;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 1000; i++) {
            System.out.println("===> 子线程 " + i);
        }
    }
}

[主线程代码] Test2.java

package example02_runnable;

public class Test2 {
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        for (int i = 0; i <= 1000; i++) {
            System.out.println("===> 主线程 " + i);
        }
    }
}

[运行结果]

img.png

2.线程中的相关方法

(1)设置优先级 setPrlorty()

优先级可以用从1到10的范围指定。10表示最高优先级(Thread.MAX_PRIORITY)，1表示最低优先级(Thread.MIN_PRIORITY)，5是普通优先级(Thread.NORM_PRIORITY，默认)。

优先级不能超出1-10的取值范围，否则抛出IllegalArgumentException

效果受操作系统影响，可能存在无效情况,因此不要有业务逻辑依赖于线程优先级，结果会无法预期

  • Thread.setPriority()用来设定线程的优先级
  • 在线程 start 方法被调用之前，线程的优先级应该被设定
  • 线程的优先级不能超过所属线程组的优先级，即可以通过控制线程组的优先级，来控制线程组下线程的最大优先级
  • 线程的优先级未设定时，默认所属的线程组的优先级
  • 未指定线程优先级时，所有线程都携带普通优先级
  • 优先级最高的线程在执行时被给予优先，最终由 CPU 调度程序决定哪一个线程被执行
  • 与线程池中等待运行机会的线程相比，当前正在运行的线程可能总是拥有更高的优先级
  • 高优先级线程不一定先于低优先级的线程运行。

[子线程代码] MyThread3.java

package example03_priority;

public class MyThread3 extends  Thread{
    public MyThread3(String name){
        super.setName(name); //设置线程名字
    }
    @Override
    public void run() {
        //super.run();
        for(int i = 0;i<=1000;i++){
            System.out.println("===> 子线程 " +super.getName() + " "+ i);
        }
    }
}

[主线程代码] Test3.java (未设置线程优先级)

package example03_priority;


public class Test3 {
    public static void main(String[] args) {
        MyThread3 mt1 = new MyThread3("A");
        MyThread3 mt2 = new MyThread3("B");
        mt1.start();
        mt2.start();
    }
}

[运行结果]

img.png

[主线程代码] Test3.java (设置线程优先级)

package example03_priority;


public class Test3 {
    public static void main(String[] args) {
        MyThread3 mt1 = new MyThread3("A");
        MyThread3 mt2 = new MyThread3("B");
        mt1.setPriority(1);
        mt2.setPriority(10);
        mt1.start();
        mt2.start();
    }
}

[运行结果]

img.png

img.png

(2)设置睡眠 sleep()

sleep，每隔x时间 去执行一个y操作。参数单位：毫秒

package example04_sleep;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MyThread4 extends Thread{
    @Override
    public void run() {
        //让子系统不停的显示系统当前时间
        while(true){
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d = new Date();
            System.out.println(sdf.format(d));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        MyThread4 mt = new MyThread4();
        mt.start();
    }
}

img.png

等待子线程执行完毕 join()

让主线程等待当前执行中子线程执行完毕。

[子线程代码]MyThread5.java

package example05_join;
public class MyThread5 extends Thread{
    @Override
    public void run() {
        // super.run();
        for(int i = 0;i<=1000;i++){
            System.out.println("===> 子线程 " + i);
        }
    }
}

[主线程代码]Test5.java

package example05_join;

public class Test {
    public static void main(String[] args) {
        MyThread5 myThread5 = new MyThread5();
        myThread5.start();
        for(int i = 0;i<=100;i++){
            System.out.println("===> 主线程 " + i);
        }
        try {
            myThread5.join(); //此时让主线程等待子线程执行完毕，再继续执行   
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        
        System.out.println("主线程执行完毕");

    }
}

让出CPU资源，让其他线程执行 yield()

让行，不代表不执行。具体谁先进行，依然由CPU决定，不能完全确定

[子线程代码]MyThread6.java

package example06_yield;

public class MyThread6 extends Thread {
    public MyThread6(String name) {
        super.setName(name);
    }

    @Override
    public void run() {
//        super.run();
        for (int i = 0; i <= 500; i++) {
            System.out.println(super.getName() + "：" + i);
            if (i % 10 == 0) {
                Thread.yield();
            }
        }
    }
}

[主线程代码]Test6.java

package example06_yield;

import example04_sleep.yield.MyThread6;

public class Test6 {
    public static void main(String[] args) {
        MyThread6 mt1 = new MyThread6("A");
        MyThread6 mt2 = new MyThread6("B");
        mt1.start();
        mt2.start();
    }
}

[运行结果截图]

img.png

正如上图所见，让行是开发者设定的希望情况，但是并不代表一定成功让行。最终的决定权还是由CPU来决定

打断线程(尤其是正在睡眠中的线程) interrupt

[子线程代码]MyThread6.java

package example07.interrupt;

public class MyThread7  extends Thread{
    @Override
    public void run() {
//        super.run();
        System.out.println("线程即将进行休眠");
        try{
            Thread.sleep(1000000);
        }catch (InterruptedException e){
//            e.printStackTrace();
            System.out.println("异常：线程休眠被打断");
        }
        System.out.println("线程被激活");
    }
}

[主线程代码]Test6.java

package example07.interrupt;

public class Test7 {
    public static void main(String[] args) {
        MyThread7 myThread7 = new MyThread7();
        myThread7.start();
        for(int i = 0;i<=100;i++){
            System.out.println("===> 主线程 " + i);
        }
        myThread7.interrupt(); // 打断正在休眠中的子线程
    }
}

[运行结果截图]

img.png

3.线程同步

线程同步：当多个线程共享同一个资源的时候，我们可以在某一个线程访问到这个资源的时候，将这个资源暂时封锁
等待当前线程执行结束，解锁该资源，其他线程才可以来继续执行。

总结：等待其他线程释放锁
目的：让线程更加安全

下面以银行取钱案例说明。
[账户对象]Account.java

package example08_sync;

public class Account {
    private  double balance;
    public Account(double balance){
        this.balance = balance;
    }
        public  void getMoney(){  //在方法声明上添加synchronized关键字 一旦执行到该方法，瞬间锁定对象Account
        if(this.balance<=0){return;}
        System.out.println("即将取走1000，目前金额为："+this.balance);
        this.balance -= 1000;
        System.out.println("成功取走1000，目前金额为："+this.balance);
    }
}

[取钱线程]GetMoneyThread.java

package example08_sync;

public class GetMoneyThread extends Thread{
    private Account acc;
    public GetMoneyThread(Account acc){
        this.acc = acc;
    }

    @Override
    public void run() {
        acc.getMoney();
    }
}

[测试类]Test8.java

package example08_sync;

public class Test8 {
    public static void main(String[] args) {
        //创建账户
        Account account  = new Account(1000);
        //创建ATM线程
        GetMoneyThread atm = new GetMoneyThread(account);
        //创建柜台线程
        GetMoneyThread table = new GetMoneyThread(account);
        //取钱
        atm.start();
        table.start();
    }
}

[运行结果]

img.png

可以发现，设置的余额不足拦截(if(this.balance<=0){return;})没有生效，出现了账户余额为负数情况。

为避免这些情况的出现，因此需要线程同步。即将多个处理统一资源的线程，进行队列化管理(锁)

实现线程同步的方法

方法1：在方法声明上添加一个synchronized关键字
package example08_sync;

public class Account {
    private  double balance;
    public Account(double balance){
        this.balance = balance;
    }
    public synchronized void getMoney(){  //在方法声明上添加synchronized关键字 一旦执行到该方法，瞬间锁定对象Account
        if(this.balance<=0){return;}
        System.out.println("即将取走1000，目前金额为："+this.balance);
        this.balance -= 1000;
        System.out.println("成功取走1000，目前金额为："+this.balance);
    }
}
方法2：在方法内部添加一个synchronized关键字
package example08_sync;

public class Account {
    private  double balance;
    public Account(double balance){
        this.balance = balance;
    }
    public synchronized void getMoney(){  //在方法声明上添加synchronized关键字 一旦执行到该方法，瞬间锁定对象Account
        synchronized (this){
            if(this.balance<=0){return;}
            System.out.println("即将取走1000，目前金额为："+this.balance);
            this.balance -= 1000;
            System.out.println("成功取走1000，目前金额为："+this.balance);
        }
    }
}
方法3：手动上锁

该方法用的最少，因为容易出现忘记解锁。

package example08_sync;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
    private  double balance;
    private Lock lock = new ReentrantLock(); //创建锁
    public Account(double balance){
        this.balance = balance;
    }
   public  void getMoney(){  //在方法声明上添加synchronized关键字 一旦执行到该方法，瞬间锁定对象Account
        lock.lock(); // 上锁
        if(this.balance<=0){return;}
        System.out.println("即将取走1000，目前金额为："+this.balance);
        this.balance -= 1000;
        System.out.println("成功取走1000，目前金额为："+this.balance);
        lock.unlock(); //解锁
    }
}

死锁

线程同步时最容易发生的问题

eg：线程A锁定资源1后，等待访问资源2；线程2锁定资源2后，等待访问资源1。

[资源对象] ResourceObjec.java

package example09_dead;

public class ResourceObject {
    public static Object obj1 = new Object();
    public static Object obj2 = new Object();
}

[线程1] DeadLock1.java

package example09_dead;

public class DeadLock1 extends Thread{
    @Override
    public void run() {
//        super.run();
        synchronized (ResourceObject.obj1){
            System.out.println("线程1 第一个资源锁定");
            try{
                //通过休眠使CPU去执行其他线程
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (ResourceObject.obj2){
                System.out.println("线程1 第二个资源锁定");
                System.out.println("线程1执行完毕");
            }
        }


    }
}

[线程2] DeadLock2.java

package example09_dead;

public class DeadLock2 extends Thread{
    @Override
    public void run() {
//        super.run();
        synchronized (ResourceObject.obj2){
            System.out.println("线程2 第二个资源锁定");
            try{
                //通过休眠使CPU去执行其他线程
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (ResourceObject.obj1){
                System.out.println("线程2 第一个资源锁定");
                System.out.println("线程2执行完毕");
            }
        }
    }
}

[测试] Test9.java

package example09_dead;

public class Test9 {
    public static void main(String[] args) {
        DeadLock1 dl1 = new DeadLock1();
        DeadLock2 dl2 = new DeadLock2();
        dl1.start();
        dl2.start();
    }
}

[运行结果]

img.png

线程的生命周期

  • [1]创建线程
  • ---[start()]--> [2]就绪状态
  • ---[CPU调度]--> [3]运行状态
    • ---[stop()]--> (跳转到4)
    • ---[IO操作、sleep]--> 阻塞状态 ---[IO结束、sleep()结束]--> (跳转到2)
  • --------------> [4]消亡状态

生产者消费者模型

案例：实现对视频进行审查，如果是不良视频，则对视频进行删除
[视频对象] Video.java

package example10_check;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

[检查视频] CheckVideo.java

package example10_check;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public class CheckVideo extends Thread{
    private static AtomicInteger i = new AtomicInteger(); //AtomicInteger原子型整数。特点：线程安全 效果等同于 int i = 0，但是比int i = 0 更安全。
    //将视频添加到缓冲区(队列)
    private BlockingQueue<Video> videos;
    public  CheckVideo(BlockingQueue<Video> videos){
        this.videos = videos;
    }
    @Override
    public void run() {
        while (true){
            String name = "不良视频"+i.incrementAndGet();// 相当于i++
            Video v = new Video(name);
            //将视频添加到队列
            try {
                System.out.println("发现不良视频"+name);
                videos.put(v);
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

[删除视频] DelVideo.java

package example10_check;

import java.util.TreeMap;
import java.util.concurrent.BlockingQueue;

public class DelVideo extends Thread {
    private BlockingQueue<Video> videos;
    public DelVideo(BlockingQueue<Video> videos){
        this.videos = videos;
    }

    @Override
    public void run() {
        while(true){
            try{
                Video video = videos.take();
                System.out.println("删除不良视频"+video.getName());
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

[测试] Test10.java

package example10_check;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Test10 {
    public static void main(String[] args) {
        BlockingQueue<Video> videos = new LinkedBlockingQueue<Video>();
        //创建3个检查视频的线程
        CheckVideo ck1 = new CheckVideo(videos);
        CheckVideo ck2 = new CheckVideo(videos);
        CheckVideo ck3 = new CheckVideo(videos);
        //创建两个删除视频的线程
        DelVideo d1 = new DelVideo(videos);
        DelVideo d2 = new DelVideo(videos);
        ck1.start();
        ck2.start();
        ck3.start();
        d1.start();
        d2.start();

    }
}

[运行结果]

img.png

萌狼蓝天
关注
专栏目录
学习笔记：多线程Java Socket编程示例
08-17
在本学习笔记中，我们将探讨如何使用Java的Socket编程实现多线程服务器，特别是通过ExecutorService创建线程池来处理客户端的并发请求。ExecutorService是一个高级的线程管理工具，它允许我们更有效地管理和控制线程...
JAVA并发编程实践-线程安全-学习笔记
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
qq_35716689的博客
03-20 25万+
CompletableFuture为Java提供了强大的异步编程能力,可以极大地提高应用的并发能力和响应速度。通过并行执行多个查询任务,我们可以大幅减少接口的响应时间,优化用户体验。同时,CompletableFuture的代码风格函数式、简洁、优雅,也使得代码更加易读易维护。 但是,异步编程也不是万能的,它需要开发者转变思维模式,还需要权衡利弊。在实际项目中,我们可以结合其他优化手段,选择合适的方案,以达到最佳的性能效果。
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3488
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java多线程实战-CountDownLatch模拟压测实现
qq_35716689的博客
03-17 25万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
热门推荐
qq_35716689的博客
03-16 25万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 24万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java学习笔记---多线程并发
weixin_44823875的博客
03-22 1600
Java学习笔记---多线程并发认识线程和进程java中线程的实现继承Thread类（多线程实现类）实现Runnable接口（==推荐使用==）Thread类和Runnable接口线程的状态线程操作的方法同步与死锁使用同步解决使用死锁解决 认识线程和进程 进程是线程一次动态执行过程，它需要经历从代码加载、代码执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。因为每个进...
Java学习笔记-多线程
cyh0503的博客
07-08 2871
并发与并行 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多...
《Java多线程编程核心技术》学习笔记（1）
洋YANG的博客
02-23 1万+
一、实现多线程的编程方式 （1）继承Thread类 public class MyThread extends Thread { @Override public void run() { super.run(); System.out.println(&amp;amp;amp;amp;quot;MyThread&amp;amp;amp;amp;quot;); } } public class Run { publi
Java修仙之路，十万字吐血整理全网最完整Java学习笔记（高级篇）
vincewm的博客
07-18 6235
本文是“Java学习路线”中Java基础知识的高级篇，主要对多线程和反射进行了深入浅出的介绍，在多线程部分，详细介绍了线程的概念、生命周期、多线程的线程安全、线程通信、线程同步，并对synchronized和Lock锁；反射部分对反射的特性、功能、优缺点、适用场景等进行了介绍。
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一部分，涉及到多线程、同步机制、线程池以及并发工具类等多个核心知识点。以下是对这些主题的详细说明： 1. **线程安全与锁 Synchronized 底层实现原理**： 线程安全是指在多...
JAVA并发编程实践-线程执行-学习笔记
07-21
总的来说，Java并发编程实践中的任务执行是一个涉及线程调度、线程池管理、任务生命周期控制、结果处理等多个方面的复杂主题。理解和掌握这些概念和技术，能够帮助开发者编写出更加高效、可靠的并发程序。
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 389
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 906
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 957
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 477
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
Java多线程学习笔记：从基础到深入
资源摘要信息:"多线程笔记_java/多线程_" 知识点： 1. 多线程基础概念： 在Java中，线程（Thread）是程序执行流的最小...以上就是多线程笔记中涉及的知识点，从基础到高级应用，对Java多线程编程有一个全面的覆盖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

萌狼蓝天

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

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

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

打赏作者

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

抵扣说明：

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

余额充值