java线程

最新推荐文章于 2024-07-09 16:46:46 发布
最新推荐文章于 2024-07-09 16:46:46 发布
阅读量92 收藏
点赞数 1
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51773207/article/details/127329242
版权

线程

在操作系统中我们引入进程是为了使多个程序能够并发执行，以提高资源利用率，那么引入线程就是为了减少程序在并发执行所付出的时间开销

进程的基本属性

  1. 我们知道进程是一个可拥有独立资源的单位，一个进程要能独立运行，他必须要有一定的资源。
  2. 进程同时又是一个可以独立调度和分配的基本单位。

并发和并行

并发性和并行性是两个相似但有区别的两个概念

  • 并发性

    两个或多个事件在同一时间间隔内发生

  • 并行性

    两个或多个事件在同一时刻发生

那么程序并发执行需要付出的时空开销需要完成以下的操作:

  1. 创建进程。分配其必须的、除处理机外的所有资源
  2. 撤销进程。先对其占有的资源执行回收操作，然后再撤销PCB(进程控制块)
  3. 进程切换。对进程进行上下文切换，需要保留当前进程的CPU环境，设置新的花费处理机时间。

由于进程是一个资源的拥有者，因而在创建、撤销、和切换中，系统必须为之付出极大的系统开销，所以我们就引入了线程。

线程的基本属性

线程作为调度和分配的基本单位(可以独立执行程序)

这样可以做到拥有资源的基本单位不施以频繁的切换，从而节省开销

单线程和多线程

  1. 单线程:同一个时刻，只允许执行一个线程
  2. 多线程:同一时刻，可以执行多个线程，比如:一个qq进程，可以同时打开多个聊天窗口，一个个迅雷进程可以下载多个文件

线程的基本使用

  • 创建线程的两种方式
    1. 继承Thread类，重写run方法
    2. 实现Runnable接口，重写run方法

在这里插入图片描述

  1. 继承Thread类，重写run方法
public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();//启动线程，最终会执行cat的run方法
    }
}
class Cat extends Thread{
    @Override
    public void run() {
        super.run();
        int count=0;
        while (true) {
            System.out.println("我是一只猫，快乐的星猫。"+(++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (count==8){
                break;
            }
        }
    }
}

2.实现Runnable接口，重写run方法

  • java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能
  • java提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
public class Thread02 {
    public static void main(String[] args) {//代理模式
        Dog dog = new Dog();
        Thread thread = new Thread(dog);//不能直接使用dog.start()会报错，因为没有start方法，但thread有
        thread.start();
    }
}
class Dog implements Runnable{

    int count=0;
    @Override
    public void run() {
        while (true){
            System.out.println("小狗汪汪叫hi..."+(++count)+Thread.currentThread().getName());

            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (count==10){
                break;
            }
        }
    }
}

  • 继承Thread vs 实现Runnable的区别

    实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承机制

多线程机制

​ 进程在执行时先执行main()线程，当其碰到start方法时，执行另一个新的线程，这些新的线程也可以创建子线程，当所有的线程结束时，程序才会终止。

既然他最后是调用的run方法，为什么不直接调用run方法呢?

由于run方法只是一个简单地方法，并不会启动一个线程

我们来看一下源码:

public synchronized void start() {
            start0();
}

start0()是本地方法，是JVM调用，底层是c/c++实现

真正实现多线程的效果是start0(),而不是run

private native void start0();

线程终止

  1. 当线程完成任务后，会自动退出
  2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
public class ThreadExit01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();

        //如果希望main线程去控制t1线程的终止，必须可以修改 loop
        //让 t1 退出run方法，从而终止 t1线程 -

        Thread.sleep(10*1000);
        t.setLoop(false);
    }
}
class T extends Thread{

    //设置一个控制变量
    private boolean loop = true;

    public boolean isLoop() {
        return loop;
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("T运行中。。。");
        }
    }
}

线程中断

public class Method01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setName("线程一");//设置线程名称
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();



        for (int i = 0;i<5;i++){
            Thread.sleep(1000);
            System.out.println("hi"+i);
        }

        t.interrupt();
    }
}
class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中");
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
            }
        }
    }
}

线程插队

  1. yield:线程的礼让，让出cpu，让其他的线程执行，但是礼让的时间不确定，所以也不一定成功
  2. join:线程的插队，插队的线程一旦插队成功，则肯定先执行完插入的线程的所有的任务。
public class Method02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for (int i =1 ;i<=20;i++){
            System.out.println("主线程吃了"+i+"个包子");
            Thread.sleep(1000);
            if (i==5) {
                //join()
                //t2.join();
                //yield
                Thread.yield();
            }
        }
    }
}
class T2 extends Thread{
    @Override
    public void run() {
        for (int i=1;i<=20;i++){
            System.out.println("子线程(老大) 吃了"+i+"个包子");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

用户线程和守护线程

  1. 用户线程:也叫工作线程，当线程的任务执行完或通知方式结束
  2. 守护线程:一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
  3. 常见的守护线程：垃圾回收机制
public class Method04 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        myDaemonThread.setDaemon(true);//设置守护线程
        myDaemonThread.start();
        for (int i =1;i<=5;i++){
            System.out.println("宝强在辛苦的工作");
            Thread.sleep(1000);
        }
    }//当主线程结束时，子线程也结束
}
class MyDaemonThread extends Thread{
    @Override
    public void run() {
        for (;;){//无限循环
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("马蓉和宋哲快乐的聊天");
        }
    }
}

线程的7种状态

在这里插入图片描述

线程同步机制

  • 在多线程编程，一些敏感的数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，保证数据的完整性

同步的具体方法 - Synchronized

  1. Synchronized在方法声明中，表示整个方法为同步方法
//使用多线程模拟三个窗口同时售票100
public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //会出现超卖现象
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();

//        SellTicket02 sellTicket01 = new SellTicket02();
//        SellTicket02 sellTicket02 = new SellTicket02();
//        SellTicket02 sellTicket03 = new SellTicket02();
//
//        Thread thread01 = new Thread(sellTicket01);
//        Thread thread02 = new Thread(sellTicket02);
//        Thread thread03 = new Thread(sellTicket03);
//
//        thread01.start();
//        thread02.start();
//        thread03.start();

        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
    }
}

//使用Synchronized实现线程同步
class SellTicket03 implements Runnable{
    public static int ticketNum = 100;
    private boolean loop = true;//控制run方法的变量
        public  synchronized void sell(){//同步方法，同一时刻只能有一个线程执行sell
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                loop=false;
                return;
            }
            //休眠50毫秒，模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数"+(--ticketNum));
        }
    @Override
    public  void run() {
        while (loop) {
            sell();
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
//使用Thread方式（超卖）
class SellTicket01 extends Thread{
    public static int ticketNum = 1000;//多个线程共享num
    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            //休眠50毫秒，模拟
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数"+(--ticketNum));
        }
    }
}

//使用Runnable（超卖）
class SellTicket02 implements Runnable{

    @Override
    public void run() {
            while (true) {
                if (SellTicket01.ticketNum <= 0) {
                    System.out.println("售票结束");
                    break;
                }
                //休眠50毫秒，模拟
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数"+(--SellTicket01.ticketNum));
            }
        }
    }

2.同步代码块

public  synchronized void sell() {//同步方法，同一时刻只能有一个线程执行sell
        if (ticketNum <= 0) {
            System.out.println("售票结束");
            loop = false;
            return;
        }
        //休眠50毫秒，模拟
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum));
    }

互斥锁

  1. java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应于一个可称为"互斥锁"的标记，这个标记用来保证在任一时刻，能有一个线程访问该对象
  3. 关键字synchronized来与对象互斥锁联系，当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性:导致程序的执行效率要降低
  5. 同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象
//来自其他对象
Object object = new Object();
public  /*synchronized*/ void sell() {//同步方法，同一时刻只能有一个线程执行sell
            synchronized (/*this*/object) {
                if (ticketNum <= 0) {
                    System.out.println("售票结束");
                    loop = false;
                    return;
                }
                //休眠50毫秒，模拟
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum));
            }
        }
  1. 同步方法(静态的)的锁为当前类本身
class SellTicket03 implements Runnable{
    public static int ticketNum = 100;
    private boolean loop = true;//控制run方法的变量
    Object object = new Object();


        //同步方法(静态的)的锁为当前类本身
        //如果在静态方法中，实现一个同步代码块
    /*
    public static void m2(){
        synchronized (SellTicket03.class){
            System.out.println("m2");
        }
    * */
    public synchronized static void m1(){
    }
    public static void m2(){
        synchronized (SellTicket03.class){
            System.out.println("m2");
        }
    }
    }

线程死锁

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁。

public class DeadLock_{
    public static void main(String[] args) {
        DeadLockDemo A = new DeadLockDemo(true);
        DeadLockDemo B = new DeadLockDemo(false);

        A.start();
        A.setName("A线程");
        B.start();
        B.setName("B线程");
    }
}
class DeadLockDemo extends Thread {
    static Object object1 = new Object();
    static Object object2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }


    //当两个线程一个进入1一个进入3就发生死锁，因为会占用对方的资源
    @Override
    public void run() {
        if (flag) {
            synchronized (object1) {
                {
                    System.out.println(Thread.currentThread().getName() + "进入1");
                    synchronized (object2) {
                        System.out.println(Thread.currentThread().getName() + "进入2");

                    }
                }
            }
        } else {
            synchronized (object2) {
                System.out.println(Thread.currentThread().getName() + "进入3");
                synchronized (object1) {
                    {
                        System.out.println(Thread.currentThread().getName() + "进入4");
                    }
                }
            }
        }
    }
}

释放锁

  1. 当前线程的同步方法、同步代码执行结束。
  2. 当前线程在同步代码块遇到break 、return
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

不会释放锁

  1. 线程执行同步代码块或同步方法时，程序调用Threed.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
  2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁

).getName() + “进入3”);
synchronized (object1) {
{
System.out.println(Thread.currentThread().getName() + “进入4”);
}
}
}
}
}
}


==释放锁==

1. 当前线程的同步方法、同步代码执行结束。
2. 当前线程在同步代码块遇到break 、return
3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

**不会释放锁**

1. 线程执行同步代码块或同步方法时，程序调用Threed.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁
网代慎平
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java 线程 block_JAVA线程的BLOCK状态实例分析
weixin_32790385的博客
02-16 2769
今天主要介绍一下线程block的状态，从实例来分析线程的block状态。背景先介绍一下线程的所有状态信息NEW: 线程创建之后，但是还没有启动(not yet started)。这时候它的状态就是NEW RUNNABLE: 正在Java虚拟机下跑任务的线程的状态。在RUNNABLE状态下的线程可能会处于等待状态， 因为它正在等待一些系统资源的释放，比如IO BLOCKED: 阻塞状态，等待锁的释放...
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信...
Java线程
sunyingboaini的博客
06-20 1万+
线程的使用
探索Java线程副本技术：深入理解与实践ThreadLocal
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
05-01 2万+
ThreadLocal作为Java线程副本技术的核心实现，为多线程编程提供了强大的线程隔离能力。深入理解其工作原理、掌握正确的使用方法、关注潜在问题及最佳实践，将有助于开发者在复杂并发场景下编写高效、安全、易于维护的代码。
Java线程阻塞
qq_43966957的博客
12-06 4750
Java线程阻塞
Java线程安全
qq_40132294的博客
10-10 2万+
前段时间有测试一个后端对账单和话单采集服务,在测试过程中有涉及到数据库读写逻辑和并发的场景,所以结合经验针对系统技术架构设计了部分并发场景结合数据库读写时可能出现的一些问题的用例,也确实出现了一些测试环境容易忽视,线上环境确确实实可能出现的问题,当然最后还是得到了妥善的解决.下面说说后端测试应该考虑的一些线程安全和数据读写方面的问题. 前提:测试环境的架构尽量向线上环境的架构靠拢,比如线上如果采用分布式集群,测试环境如果是单机,那么部分问题自然无法暴露,如果测试环境无足够资源模拟线上的几十台集群环境,那么
Java 线程间通信
WYSCODER的博客
04-17 5551
Java线程间通信
【面试精讲】Java线程6种状态和工作原理详解，Java创建线程的4种方式
小明的Java问道之路
03-10 8539
Java线程6种状态和工作原理详解，Java创建线程的4种方式
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6242
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
java 线程的优先级
peinanwei__的博客
05-04 4208
线程优先级 现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。线程分配到的时间片多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。 在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优......
Java线程生命周期
qq_44146560的博客
03-29 4875
一、操作系统层面 在操作系统中线程生命周期可以分为五种状态。分别是：初始状态、可运行状态、运行状态、休眠状态和终止状态。 二、Java层面 但是在Java中，线程的生命周期有六种状态，分别是：新键NEW,就绪RUNNABLE、阻塞BLOCKED、等待WAITING、超时等待TIMED_WAITING、终止Terminated。Java中将操作系统中断休眠状态分为了三种状态，也就是：BLOCKED、WAITING、TIMED_WAITING。只要 Java 线程处于这三...
java线程分析工具TDA
06-21
Java线程分析是Java开发中的重要环节，尤其是在处理性能优化、死锁排查或者并发问题时。TDA（Thread Dump Analyzer）是一款强大的Java线程分析工具，它能够帮助开发者深入理解应用在运行时的线程状态，包括线程的...
java线程基础
12-21
注：多线程下载、断点续传中多线程并不是提高了宽带速度，而是提高了程序的效率（打个比方就是本来是一个干，多线程就是多个人一起做一件事，并且彼此之间独立，即每个人负责一部分,因为是独立的，所以一个出问题...
Java 线程
06-01
NULL 博文链接：https://yangeoo.iteye.com/blog/2219492
java Object 转 Integer
servepeople的博客
07-09 217
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1009
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 673
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
最新发布
qq_44304677的博客
07-09 92
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
java线程和线程池
06-08
在Java中，线程是程序执行的基本单元，用于并发执行任务。每个线程都有自己的生命周期，包括创建、运行、阻塞和终止。线程的创建可以通过继承Thread类或实现Runnable接口来实现。 线程池则是Java中一种高效的线程管理机制，它预先创建一定数量的工作线程，并在需要执行任务时从线程池中获取线程进行处理，当任务完成后，线程会返回到线程池等待下一次调度，而不是立即结束。这样可以避免频繁地创建和销毁线程带来的开销，提高系统的性能和资源利用率。 以下是Java线程和线程池的一些关键点： 1. **线程创建**： - **继承Thread类**：创建自定义线程类并重写run()方法。 - **实现Runnable接口**：创建Runnable接口的实现类，提供run()方法，然后用Thread构造函数创建Thread实例。 2. **线程状态**： - 新建（New）：线程对象被创建但还未启动。 - 运行（Runnable）：线程正在执行run()方法。 - 阻塞（Blocked）：线程因某个条件而暂停，如I/O操作等待数据。 - 等待（Waiting）：线程在调用wait()方法后，进入等待状态，直到被其他线程唤醒。 - 守护（Terminated）：非守护线程完成或主线程结束，守护线程自动退出。 3. **线程池组件**： - ExecutorService：线程池的核心接口，提供了提交任务和控制线程的方法。 - ThreadPoolExecutor：实现了ExecutorService，包含核心线程数、最大线程数、任务队列等配置。 - ScheduledThreadPoolExecutor：支持定时和周期性任务。 4. **线程池的优势**： - **资源复用**：减少线程创建和销毁的开销。 - **线程管理和调度**：灵活设置线程数量、线程优先级和任务执行策略。 - **避免死锁**：由于任务有顺序地等待特定资源，减少了死锁的可能性。 - **可扩展性**：随着任务增加，线程池可以根据需要动态调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

网代慎平

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

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

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

打赏作者

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

抵扣说明：

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

余额充值