Java笔记：多线程

最新推荐文章于 2024-04-04 17:53:31 发布
最新推荐文章于 2024-04-04 17:53:31 发布
阅读量111 收藏
点赞数
分类专栏： Java笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alice_Lee_Lee/article/details/113253096
版权

1. 基本概念：程序、进程、线程

程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程是程序的一次执行过程，或者是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程（生命周期）

  • 程序是静态的，进程是动态的
  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程，进程可进一步细化为线程，是一个程序内部的一条执行路径

  • 若一个进程同一时间并行执行多个线程，就是支持多线程的
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器，线程切换的开销小
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间，它们从同一堆中分配对象，可以访问想用的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全隐患

一个Java应用程序，至少有三个线程：main() 主线程，gc() 垃圾回收线程，异常处理线程。如果发生异常，会影响主线程。

并行与并发：

  • 并行：多个CPU同时执行多个任务
  • 并发：一个CPU（采用时间片）同时执行多个任务

使用多线程的优点：

  • 提高应用程序的响应。对图形化界面更有意义，可增强用户体验
  • 提高计算机系统CPU的利用率
  • 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，便于理解和修改

何时需要多线程：

  • 程序需要同时执行两个或多个任务
  • 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
  • 需要一些后台运行的程序时

2. 线程的创建和使用

2.1 线程创建的方式一：继承于Thread类

  • 创建一个继承于Thread类的子类
  • 重写Thread类中的run()，将此线程执行的操作声明在run()中
  • 创建Thread类的子类的对象，通过该对象调用start() 方法

代码Demo：

public class ThreadDemo {
    public static void main(String[] args) {
		MyThread t1 = new MyThread();
        t1.start();
        //t1.run(); // 此时是普通的对象调用方法，并没有启动线程
        //t1.start(); // 不能start已经start过的线程，会报IllegalThreadStateException异常；
        // 如果要再次完成某些功能，需要new线程对象再次start
        for (int i = 0; i < 50; i++) {
            System.out.println("Hello World！");
        }
	}
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
        	if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

Thread类的有关方法：

  • void start() ：① 启动当前线程； ② 调用当前线程的run()
  • void run()：线程在被调度时执行的操作
  • static Thread currentThread()：返回执行当前代码的线程
  • String getName()：获取当前线程的名字
  • void setName(String name)：设置当前线程的名字（Thread类有初始化线程名的构造器public Thread(String name)）
  • static void yield()：释放当前CPU的执行权（但在之后的执行中，CPU仍有可能切换到该线程再次执行）
  • join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完，线程a才结束阻塞状态
  • static void sleep(long millis)：阻塞当前线程指定的millis毫秒数
  • void stop()：强制结束当前线程（已弃用）
  • boolean isAlive()：判断当前线程是否存活

线程的调度

Java的调度方法：

  • 同优先级线程组成先进先出队列，使用时间片策略
  • 对高优先级，使用优先调度的抢占式策略

线程的优先级：

  • 等级从1到10，其中1，5，10是三个常量（MAX，MIN，NORM_PRIORITY），默认优先级是5
  • int getPriority()：获取线程的优先级；void setPriority(int newPriority)：设置线程的优先级
  • 线程创建时继承父线程的优先级
  • 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才能执行

2.2 线程创建的方式二：实现Runnable接口

  • 创建一个实现了 Runnable 接口的类
  • 实现类去实现 Runnable 中的抽象方法：run()
  • 创建实现类的对象，作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象
  • 调用 Thread 类的对象的 start()

代码Demo：

public class RunnableDemo {
    public static void main(String[] args) {
    	MyRunnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        t1.start();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
    	for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
            	System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
    }
}

2.3 比较创建线程的两种方式

  • 开发中优先选择实现 Runnable 接口的方式，原因：① 没有类的单继承性的限制；② 更适合处理多个线程有共享数据的情况
  • 联系：public class Thread implements Runnable {}
  • 相同点：① 都需要重写 run() ，将线程要执行的逻辑声明在 run() 中；② 要想启动线程，都要调用 Thread 类的 start()

2.4 线程的分类

  • Java的线程分为两类：① 守护线程；② 用户线程
  • 守护线程是用来服务用户线程的，通过在 start() 前调用void setDaemon(boolean on)可以将一个用户线程变成一个守护线程
  • 若 JVM 中都是守护线程，当前 JVM 将退出

3. 线程的生命周期

JDK中用Thread.State类定义了线程的几种状态：

  • 新建：当一个 Thread 类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  • 就绪：处于新建状态的线程被 start() 后，将进入线程队列等待 CPU 时间片，此时它已具备了运行的条件，只是没分配到 CPU 资源
  • 运行：当就绪的线程被调度并获得 CPU 资源时，便进入运行状态，run() 定义了线程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时终止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地终止或出现异常导致结束
    在这里插入图片描述

4. 线程的同步

public class RunnableDemo {
    public static void main(String[] args) {
    	MyWindow window = new MyWindow();
        new Thread(window).start();
        new Thread(window).start();
        new Thread(window).start();
    }
}

class MyWindow implements Runnable {
    private int ticket = 100;

	@Override
    public void run() {
    	while (true) {
            if (ticket > 0) {
            	try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                	e.printStackTrace();
                }
                
    			System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
            	ticket--;
            } else {
            	break;
            }
        }
    }
}
  • 实际问题：三个窗口共出售100张票，会出现重票、错票的现象（线程安全问题）
  • 原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
  • 解决：当一个线程在操作车票时，在该线程完成操作前，其他线程不能参与进来，哪怕该线程被阻塞，也不能改变

在Java中，通过同步机制，来解决线程的安全问题。

同步解决了线程的安全问题，但操作同步代码时，只能有一个线程参与，相当于是单线程的过程，效率低。

4.1 同步方式一：同步代码块

synchronized(同步监视器){
	需要被同步的代码
}
  • 操作共享数据的代码，即为需要被同步的代码
  • 同步监视器（锁）：任何一个类的对象，都可以充当锁（多个线程必须要共用同一把锁）

实现 Runnable 接口的方式：

class MyWindow implements Runnable {
    private int ticket = 100;

	@Override
    public void run() {
    	while (true) {
    		synchronized (this) {
	            if (ticket > 0) {
	            	try {
	                    Thread.sleep(100);
	                } catch (InterruptedException e) {
	                	e.printStackTrace();
	                }
	                
	    			System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
	            	ticket--;
	            } else {
	            	break;
	            }
	        }
        }
    }
}

继承 Thread 类的方式：

class Window extends Thread {
    private static int ticket = 100;

	@Override
    public void run() {
    	while (true) {
    		synchronized (Window.class) {
	            if (ticket > 0) {
	            	try {
	                    Thread.sleep(100);
	                } catch (InterruptedException e) {
	                	e.printStackTrace();
	                }
	                
	    			System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
	            	ticket--;
	            } else {
	            	break;
	            }
	        }
        }
    }
}

补充：在实现 Runnable 接口创建多线程的方式中，我们可以考虑使用this充当同步监视器；在继承 Thread 类创建多线程的方式中，慎用this来充当同步监视器，可以考虑使用当前类来充当同步监视器

4.2 同步方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，不妨将此方法声明为同步的。

实现 Runnable 接口的方式：

class MyWindow implements Runnable {
    private int ticket = 100;

	@Override
    public void run() {
    	while (true) {
    		show();
        }
    }

	private synchronized void show() {// 此时的同步监视器就是this
		if (ticket > 0) {
       		try {
       			Thread.sleep(100);
       		} catch (InterruptedException e) {
           		e.printStackTrace();
            }
         
			System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
	       	ticket--;
        }
	}
}

继承 Thread 类的方式：

class Window extends Thread {
	private static int ticket = 100;

	@Override
	public void run() {
		while (true) {
			show();
		}
	}

	private static synchronized void show() { // 此时同步监视器是当前类
		if (ticket > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
			ticket--;
		}
	}
}

总结：

  • 同步方法仍然涉及到同步监视器，只是不需要显式的声明
  • 非静态同步方法的同步监视器是 this ，静态同步方法的同步监视器是当前类本身

4.3 线程同步会产生的问题：死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

解决方法：① 专门的算法、原则；② 尽量减少同步资源的定义；③ 尽量避免嵌套同步

4.4 同步方式三：Lock锁

  1. 实例化 ReentrantLock，生成对象 lock
  2. 调用 lock 的 lock() 加锁
  3. 调用 lock 的 unlock() 释放锁

实现 Runnable 接口的方式：

class Window implements Runnable {

    private int ticket = 100;

	// 1.实例化ReentrantLock，参数代表是否公平调度，true表示会按照先后顺序来进行调度
	private ReentrantLock lock = new ReentrantLock(true);

	@Override
    public void run() {
    	while (true) {
            try {
            	// 2.调用lock()加锁
                lock.lock();
                if (ticket > 0) {
                	try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                    	e.printStackTrace();
                   	}

					System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
					ticket--;
                } else {
                    break;
                }
            } finally {
                // 3.调用unlock()解锁
                lock.unlock();
            }
        }
    }
}

synchronized 与 Lock 的区别：

  • synchronized 机制在执行完相应的同步代码以后，会自动的释放同步监视器
  • Lock 需要手动的启动同步，结束同步

5. 线程的通信

例：两个线程轮流打印1-100

class NumberPrint implements Runnable {
	private int num = 1;
	@Override
    public void run() {
    	while (true) {
            synchronized (this) {
            	notifyAll();//唤醒其他处于阻塞状态线程
                if (num <= 100) {
                	System.out.println(Thread.currentThread().getName() + ": " + num);
                    num++;
                    try {
                        wait();//阻塞当前线程并释放锁
                    } catch (InterruptedException e) {
                    	e.printStackTrace();
                    }
                } else {
                	break;
                }
            }
        }
    }
}

三个方法：

  • wait()：当前线程进入阻塞状态并释放同步监视器
  • notify()：唤醒被 wait 的一个线程（优先级高的先被唤醒，如果优先级一样就随机唤醒）
  • notifyAll()：唤醒所有被 wait 的线程

注意：

  1. 这三个方法只能够使用在同步代码块或同步方法中
  2. 这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现 IllegalMonitorStateException

sleep() 和 wait() 的比较：

  1. 相同点：都可以使当前线程进入阻塞状态

  2. 不同点：

    ① 两个方法声明的位置不同： sleep() 声明在 Thread 类中， wait() 声明在 Object 类中
    ② 调用的范围不同： sleep() 可以在任何场景调用， wait() 只能在同步代码块或同步方法中调用
    ③ 关于同步监视器的释放： sleep() 不释放同步监视器， wait() 会释放同步监视器

6. JDK5.0新增线程创建方式

6.1 实现Callable接口

  1. 创建一个实现 Callable 接口的实现类
  2. 实现 call()，将此线程需要执行的操作声明在 call() 中
  3. 创建 Callable 接口实现类的对象
  4. 将 Callable 接口实现类的对象作为参数传递到 FutureTask 的构造器中，创建 FutureTask 对象
  5. 将 FutureTask 对象作为参数传递到 Thread 的构造器中，创建 Thread 对象，调用 start() 启动线程
  6. 获取 Callable 接口实现类中的 call() 的返回值
public class ThreadNew {
    public static void main(String[] args) {
    	NumberThread numberThread = new NumberThread();
    	FutureTask task = new FutureTask(numberThread);
    	new Thread(task).start();
    	try {
            Object o = task.get();// 获取numberThread的call()的返回值
            System.out.println(o);
        } catch (InterruptedException | ExecutionException e) {
        	e.printStackTrace();
        }
    }
}

class NumberThread implements Callable {
	@Override
    public Object call() throws Exception {
    	int total = 0;
        for (int i = 0; i <= 100; i = i + 2) {
        	System.out.println(Thread.currentThread().getName() + ": " + i);
        	total += i;
        }
        return total;
    }
}

与Runnable接口比较

  • 相比 run()，call() 可以有返回值
  • call() 可以抛出异常，被外面的操作捕获，获取异常的信息
  • Callable 支持泛型，指定 call() 的返回值类型
  • 需要借助FutureTask类，比如获取返回结果，FutureTask 也支持泛型，指定获取 call() 返回值的类型

6.2 使用线程池

  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
  • 步骤：① 提供指定线程数量的线程池；② 执行指定的线程的操作 （execute 与 submit）
    public class ThreadByPool {
	public static void main(String[] args) throws Exception {
		ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
		service.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i = i + 2) {
                	// 此时的名字是：pool-1-thread-2
                	System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        });// 适合使用 Runnable
        Future<Integer> future = service.submit(new Callable<Integer>() {
        	@Override
            public Integer call() throws Exception {
            	int total = 0;
                for (int i = 0; i <= 100; i = i + 2) {
                	System.out.println(Thread.currentThread().getName() + ": " + i);
                    total += i;
                }
                return total;
            }
        });//适合使用 Callable
        Integer sum = future.get();
        System.out.println(sum);
        service.shutdown();// 关闭线程池
	}
}
  • 优点：
    1. 提高响应速度（减少了创建新线程的时间）
    2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    3. 便于线程管理
Alice_LMY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面试笔记：Java多线程的四种实现方法并详细举例介绍
蓝多多的小仓库
07-16 850
Q同学你好，问你一下，Java多线程有几种实现方法？可以分别进行举例介绍吗？一共有四种1、继承Thread类；2、实现Runnable接口；3、实现Callable接口通过FutureTask包装器来创建Thread线程；4、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，而后两种是带返回值的。在JDK5.0之前，创建线程有2种方式，一种是继承Thread类，另外一种是实现Runnable接口。详细举例介绍。......
Java 多线程总结笔记
N0tExpecterr0r的博客
09-19 4348
Java多线程总结笔记 实现多线程的方法 查看Thread类的源码，可以发现它实现了Runnable接口，然后在自己的run方法中调用了Runnable的run方法。这里其实就是静态代理这一设计模式，Thread是代理角色，而Runnable则是真实角色。在Thread的start方法中，会为我们开辟新的线程并执行其run方法，而Thread的run方法会调用它内部持有引用的Runnable的ru...
【Java笔记】多线程0：JVM线程是用户态还是内核态？Java 线程与OS线程的联系
Hansdas的博客
04-04 1224
复盘一下Java中，JVM线程与实际操作系统中线程的一些联系
Java笔记-多线程相关
IT1995的博客
12-27 4905
ava多线程和C++里面的多线程有些地方不一样。 毕竟套了一个java虚拟机。对此记录下。 Java语言内置多线程支持： 一个java程序实际上是一个JVM进程。 JVM用一个主线程来执行main()方法。 在main()方法中又可以启动多个进程。 Java多线程创建MyThread类逻辑： 1.从Thread派生； 2.覆写run...
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3253
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 16万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java笔记-多线程中同步加锁相关
IT1995的博客
12-30 5220
Java程序入口就是由JVM启动的main线程： main线程又可以启动其他线程。当所有线程都运行结束时JVM退出，进程结束。 守护线程（Daemon）：守护线程是为其他线程服务的线程，所有的非守护线程都执行完毕后，虚拟机才会退出。 守护线程的特点：不能持有资源（如打开文件等） 创建守护线程： setDaemon(true); 下面来演示下，子线程中有死循环，而主线程退出...
Java黑马程序员-多线程笔记
luohanisme的博客
10-17 950
哔哩哔哩java黑马视频笔记
狂神说多线程笔记整理
doris的博客
02-16 1万+
狂神说多线程笔记整理
学习笔记：多线程Java Socket编程示例
08-17
在本学习笔记中，我们将探讨如何使用Java的Socket编程实现多线程服务器，特别是通过ExecutorService创建线程池来处理客户端的并发请求。ExecutorService是一个高级的线程管理工具，它允许我们更有效地管理和控制线程...
Java多线程笔记
03-11
Java多线程笔记 Java多线程笔记是 Java 编程语言中关于多线程编程的笔记，涵盖了线程基础知识、线程优先级、线程状态、守护线程、构造线程、线程中断等多方面的内容。 获取简单 main 程序中的线程 在 Java 中，...
Java多线程源码笔记.pdf
05-08
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统效率。在Java中，实现多线程主要有两种方式：通过继承Thread类和实现Runnable接口。Thread类提供了创建新线程的基本功能，而Runnable...
java笔记五：多线程地使用.pdf
10-26
java笔记五：多线程地使用.pdf
Java多线程自学笔记
01-19
Java多线程自学笔记
b050闲置图书分享-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
本次开发的闲置图书分享平台实现了收货地址管理、字典管理、公告管理、留言板管理、图书管理、图书收藏管理、图书评价管理、图书订单管理、用户管理、管理员管理等功能。系统用到了关系型数据库中王者MySql作为系统的数据库，有效的对数据进行安全的存储，有效的备份，对数据可靠性方面得到了保证。并且程序也具备程序需求的所有功能，使得操作性还是安全性都大大提高，让闲置图书分享平台更能从理念走到现实，确确实实的让人们提升信息处理效率。 管理图书的数据，此页面主要实现图书的增加、修改、删除、查看的功能。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。
《大学生职业生涯规划与就业指导》大一阶段课程作业
最新发布
07-24
《大学生职业生涯规划与就业指导》大一阶段课程作业
开题报告潮汕特产直销系统 已通过开题答辩的.doc
07-23
随着互联网的高速发展，人们的生活方式发生了翻天覆地的变化，在过去，人们想要购买很远地方的东西会非常麻烦，因为是通信和交通都不是十分的方便，而现在网络购物成为了人们日常生活中不可或缺的一部分。在这样的背景下，互联网与传统行业的融合已经成为了一种不可阻挡的趋势。对于中国特色的潮汕特产来说，这一趋势也带来了巨大的变革和发展机遇[1]。
Python性能优化：掌握性能分析工具的实战指南
07-23
Python是一种广泛使用的高级编程语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键词）。这使得Python被认为是一种易于学习的语言，同时具备强大的功能，适合初学者和经验丰富的程序员。 Python的主要特点包括： 1. **易于学习**：Python有相对较少的关键字，结构简单，和一个明确定义的语法。 2. **易于阅读**：Python代码定义的清晰度使得它像可执行伪代码。 3. **易于维护**：Python的成功在于它的源代码是相当容易维护的。 4. **广泛的标准库**：Python的标凑库很庞大，包含用于互联网通信、网络通信、数据压缩、加密、系统管理等的模块。 5. **跨平台**：Python可以在多种操作系统上运行，包括但不限于Windows、Mac OS X、Linux等。 6. **解释型语言**：Python是一种解释型语言，这意味着开发过程中没有编译步骤。 7. **动态类型系统**：Python不会在编写
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值