线程基础

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量178 收藏
点赞数 1
分类专栏： 线程 文章标签： java 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lo_ol1/article/details/115485652
版权

线程基础

创建线程的方式:

1.继承Thread类

什么是run方法：run方法就是线程要执行的任务方法；

重写run方法：

public class MyThread extends Thread{
@Override
public void run() {
//这里的代码 就是一条新的执行路径
//这个执行路径的触发方式，不是调用run方法。而是通过调用thread对象的start来启动任务
			for (int i=0;i<10;i++){
				System.out.println("线程可以吃吗？"+i);
			}
}
}

开启线程：

public class Demo {
    public static void main(String[] args) {
        MyThread m=new MyThread();
        m.start();//m线程开启
        for (int i=0;i<10;i++){
            System.out.println("线程当然可以吃！"+i);
        }
    }
}

运行结果：

线程能吃吗？0
线程当然可以吃！0
线程能吃吗？1
线程当然可以吃！1
线程能吃吗？2
线程当然可以吃！2
线程能吃吗？3
线程当然可以吃！3

2.实现Runnable接口

Runnnable接口是用于给线程执行的任务；

  • 实现Runnnable接口与继承Thread类相比的优势是：
  1. 实现runnable接口是通过创建任务，然后给线程分配的方式来实现的多线程。更适合多个线程同时执行相同任务的情况。
  2. 可以避免单继承所带来的局限性
  3. 任务与线程本身是分离的，提高了程序的健壮性
  4. 后续学习的线程技术，只接受runnable类型的任务，而不接受Thread类型的线程。

实现方式：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i=0;i<10;i++){
            System.out.println("线程能吃吗？"+i);
        }
    }
    }

public class Demo {
    public static void main(String[] args) {
        //实现runnable
        //1.创建一个任务对象
        MyRunnable r=new MyRunnable();
        //2.创建一个线程， 并为其分配一个任务
        Thread  t=new Thread(r);
        //3.执行这个线程
        t.start();
        for (int i=0;i<10;i++){
            System.out.println("疑似地上霜"+i);
        }
    }
}

运行结果：

线程当然可以吃！5
线程能吃吗？6
线程当然可以吃！6
线程能吃吗？7
线程能吃吗？8
线程能吃吗？9
线程当然可以吃！7

可见线程执行任务是抢占式的，不保证顺序。

3.实现callable接口

Runnable 与 Callable的相同点:

1.都是接口
2.都可以编写多线程程序
3.都采用Thread.start()启动线程

Runnable 与 Callable的不同点:

1.Runnable没有返回值；Callable可以返回执行结果
2.Callable接口的call()允许抛出异常；Runnable的run()不能抛出

实现方式：
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("我是callable！");
        return null;
    }
}


public class CallableDemo {
    public static void main(String[] args) {
        MyCallable c=new MyCallable();
        FutureTask <String> f=new FutureTask<>(c);
        new Thread(f).start();
    }
}

运行结果：

我是callable！

线程的休眠：

public class ThreadSleepDemo {
public static void main(String[] args) throws InterruptedException {
//线程的休眠 sleep
for (int i=0;i<10;i++){
System.out.println(i);
Thread.sleep(1000);//睡眠一秒，单位是毫秒
}
}
}

线程的阻塞与死亡

线程阻塞是什么？
是所有消耗时间的操作，比如接收用户输入，或者文件读取；
线程的结束：
一个线程是一个独立的执行路径，他是否结束，应该由线程自身决定

public class Demo3 {
    public static void main(String[] args) {
        Thread t1= new Thread(new MyRunnable());
        t1.start();
        for (int i=1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            //Thread.currentThread().getName()方法用于获取当前线程名字
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t1.interrupt();  //给线程t1添加中断标记，只是告知线程应该死亡，并不决定死亡，具体操作在catch块
    }
    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i=1;i<=100;i++){
             System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    return;//结束线程
                }
            }
            }
    }
}

运行结果：

main:1
Thread-0:1
Thread-0:2
main:2
main:3
Thread-0:3
main:4
Thread-0:4
Thread-0:5
main:5
main:6
Thread-0:6
Thread-0:7
main:7
main:8
Thread-0:8
main:9
Thread-0:9
Thread-0:10
main:10
Thread-0:11

守护线程：

线程：分为守护线程和用户线程
用户线程：当一个进程不包含任何用户线程时，进行结束。
守护线程：用于守护用户线程线程,当最后一个用户线程结束时 ，所有守护线程自动死亡

public class Demo4 {
    public static void main(String[] args) {
        Thread t1= new Thread(new Demo3.MyRunnable());
        t1.setDaemon(true);//设置t1为守护线程
        t1.start();
        for (int i=1;i<=10;i++){//主线程循环10次
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i=1;i<=100;i++){//守护线程循环100次
            System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：

main:1
Thread-0:1
Thread-0:2
main:2
Thread-0:3
main:3
Thread-0:4
main:4
main:5
Thread-0:5
Thread-0:6
main:6
main:7
Thread-0:7
Thread-0:8
main:8
main:9
Thread-0:9
Thread-0:10
main:10
Thread-0:11

结果表示：当主线程死亡时，守护线程不管是否执行完毕，都随主线程一起死亡

线程不安全问题：

因为线程是抢占执行的，当 cpu 执行一个线程过程时，调度器可能调走CPU，去执行另一个线程，此线程的操作可能还没有结束，这个时候多个线程尝试修改同一个变量会很容易出现不同步问题。

线程不安全解决方式:

1.同步代码块（隐式锁）

/*
* 线程同步synchronized
* */
public class ThreadSafe {
    //格式：synchronized(锁对象（任何对象）){}
    public static void main(String[] args) {
        //线程不安全
        Runnable r=new Ticket();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count=10;
        private Object o=new Object();
        @Override
        public void run() {
        while (true){
            synchronized (o){
                if (count>0){
                    //卖票
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                }else
                    break;
            }
            }
        }
    }
}

运行结果：

正在准备卖票
Thread-0出票成功，余票：9
正在准备卖票
Thread-0出票成功，余票：8
正在准备卖票
Thread-0出票成功，余票：7
正在准备卖票
Thread-0出票成功，余票：6
正在准备卖票
Thread-0出票成功，余票：5
正在准备卖票
Thread-2出票成功，余票：4
正在准备卖票
Thread-2出票成功，余票：3
正在准备卖票
Thread-2出票成功，余票：2
正在准备卖票
Thread-2出票成功，余票：1
正在准备卖票
Thread-2出票成功，余票：0

2.同步方法（隐式锁）

public class SafeMethod {
        public static void main(String[] args) {
        //线程不安全
        Runnable r=new ThreadSafe.Ticket();//new一次一个对象，多次new锁不了
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
        static class Ticket implements Runnable{
            //票数
            private int count=10;
            @Override
            public void run() {
                while (true){
                boolean flag=sale();
                if (!flag){
                    break;
                }
                }
            }
            public synchronized boolean sale(){
                if (count>0){
                    //卖票
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                    return true;
                }
                return false;
            }
            }
        }

运行结果：

正在准备卖票
Thread-0出票成功，余票：9
正在准备卖票
Thread-0出票成功，余票：8
正在准备卖票
Thread-0出票成功，余票：7
正在准备卖票
Thread-0出票成功，余票：6
正在准备卖票
Thread-0出票成功，余票：5
正在准备卖票
Thread-0出票成功，余票：4
正在准备卖票
Thread-0出票成功，余票：3
正在准备卖票
Thread-0出票成功，余票：2
正在准备卖票
Thread-0出票成功，余票：1
正在准备卖票
Thread-0出票成功，余票：0

3.显式锁（更体现控制锁的概念）

public class LockBig {
    public static void main(String[] args) {
        Runnable r=new Ticket();//new一次一个对象，多次new锁不了
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count=10;
        //显式锁
        /*private Lock l=new ReentrantLock();*///默认不公平锁抢占
        private Lock l=new ReentrantLock(true);//true表示公平锁,先来先得
        @Override
        public void run() {
            while (true){
                l.lock();
                if (count>0){
                    //卖票
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                }else
                    break;
                l.unlock();
            }
        }
    }
}

线程池

线程池的作用：

1.降低资源消耗；
2.提高响应速度；
3.提高线程的可管理性；

1.缓存线程池:

  • 缓存线程池:
  • (长度无限制)
  • 任务加入后执行流程
    1：判断线程池是否存在空闲线程
    2：存在则使用
    3：不存在，则创建线程，并放入线程池，然后使用
public class Demo1 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();//创建缓存线程池
        service.execute(new Runnable() { //线程池执行任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
            }
        });
        service.execute(new Runnable() { //线程池执行任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
            }
        });
        service.execute(new Runnable() { //线程池执行任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
            }
        });

        try {
            Thread.sleep(1000);//休眠一秒，测试线程是否能复用
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() { //线程池执行任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
            }
        });
    }
}

运行结果:

pool-1-thread-1线程池能游泳吗？
pool-1-thread-2线程池能游泳吗？
pool-1-thread-3线程池能游泳吗？
pool-1-thread-3线程池能游泳吗？

2.定长线程池：

  • 定长线程池：
  • （长度是指定的数值）
  • 任务加入后执行流程：
    1：判断线程池是否存在空闲线程
    2：存在则使用
    3.不存在空闲线程，且线程池未满的情况下，则创建线程 并放入线程池，然后使用
    4.不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
public class Demo2 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"听人说可以！");
            }
        });
    }
}

执行结果：（第三行3秒后出现）


pool-1-thread-1线程池能游泳吗？
pool-1-thread-2线程池能游泳吗？
pool-1-thread-2听人说可以！

3.单线程线程池：

* 单线程线程池.
* 执行流程：
* 1.判断线程池的那个线程 是否空闲
* 2.空闲则使用
* 3.不空闲则等待 池中的单个线程空闲后 使用

public class Demo3 {
    public static void main(String[] args) {
        ExecutorService service= Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程池能游泳吗？");
            }
        });
    }
}

执行结果：

pool-1-thread-1线程池能游泳吗？
pool-1-thread-1线程池能游泳吗？
pool-1-thread-1线程池能游泳吗？

4.周期性任务线程池：

  • 周期性任务线程池
    1：判断线程池是否存在空闲线程
    2：存在则使用
    3.不存在空闲线程，且线程池未满的情况下，则创建线程 并放入线程池，然后使用
    4.不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
    周期性任务执行时：
    定时执行，当某个时机触发时，自动执行某任务。

定时执行

    * 参数1. 定时执行的任务
    * 参数2.时长数字
    * 参数3.时长数字的时间单位TimeUnit的常量指定

public class Demo4 {
    public static void main(String[] args) {
        ScheduledExecutorService service= Executors.newScheduledThreadPool(2);
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程池能游泳吗？");
            }
        },5, TimeUnit.SECONDS);
    }
}

五秒后执行结果：

线程池能游泳吗？

周期性执行任务

    * 周期性执行任务
    * 参数1.任务
    * 参数2.延迟时长数字（第一次执行在什么时间之后）
    * 参数3.周期时长数字（每隔多久执行一次）
    * 参数4.时长数字单位

public class Demo4 {
    public static void main(String[] args) {
        ScheduledExecutorService service= Executors.newScheduledThreadPool(2);
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("好像不可以吧！");
            }
        },5,1,TimeUnit.SECONDS);
    }
}

执行结果：（先等五秒开始执行，执行第一条后，每隔一秒执行一次）

好像不可以吧！
好像不可以吧！
好像不可以吧！
好像不可以吧！
好像不可以吧！
好像不可以吧！
南山一只鸟
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
多线程基础
12-22
本文将深入探讨多线程的基础知识，包括线程的创建、使用以及中断。 一、线程的创建方式 1. 继承Thread类创建线程 创建线程的一种方式是通过继承`Thread`类。这样做的好处是，`this`关键字可以直接代表当前运行的...
太原理工大学java实验报告-实验四
m0_74243656的博客
01-23 1255
在未来的实践中，我将继续探索多线程编程，更加灵活地应用于程序设计中，以满足不同场景下的需求，并提高程序的性能和用户体验。通过利用多个线程并发执行，我能够在程序中创建多个对象，每个对象代表一个动画元素，然后通过不同的线程控制这些元素的运动、显示和交互，从而实现更生动和流畅的动画效果。线程代表程序中的一条执行路径，理解线程的生命周期（新建、就绪、运行、阻塞、终止）让我能够更好地控制和管理程序的执行顺序和并发性。：尽量避免嵌套锁、谨慎设计资源获取的顺序，并及时释放占用的资源，避免死锁的发生。
Educoder--Java高级特性 - 多线程基础（1）使用线程
weixin_45803282的博客
05-18 9086
第一题 请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下： 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下： 1 3 5 7 9； 使用实现Runnable接口的方式创建一个名为ThreadClassTwo的类，重写run方法，编写start方法，run方法需要实现打印0-10之间的偶数，输出结果如下： 0 2 4 6 8 10 ThreadClassOne /**
1-21 线程1
WilsonDone的博客
10-25 169
进程：是指一个内存中运行的**【应用程序】
Java 线程&同步习题答案
kai46385076的专栏
07-13 2014
基础题 练习一：多线程开启 问题： 请描述Thread类中的start()方法与run()方法的区别。 答： 线程对象调用run()方法不开启线程，仅是对象调用方法。线程对象调用start()方法开启线程，并让jvm调用run()方法在开启的线程中执行。 练习二：创建多线程 问题： 请描述创建线程的两种方式。 答： 第一种方式是将类声明为 Thread 的子类。 1.定义Thread类的子...
启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5 然后是线程2打印6,7,8,9,10 然后是线程3打印11,12,13,14,15.接着再由线程1打印16,17,18,19,20....
放肆桀骜
03-30 1万+
启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5 然后是线程2打印6,7,8,9,10 然后是线程3打印11,12,13,14,15.接着再由线程1打印16,17,18,19,20…依次类推, 直到打印到60。 提示：定义一个同步方法，在方法中使用循环的方式输出连续的5个数字，方法执行前，可以通过标记的方式判断是否是当前线程应该执行，如果是，则执行输出逻辑，如果不是，则wait进入等待...
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6269
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Qt 多线程基础及线程使用方式
热门推荐
weixin_49730048的博客
10-15 3万+
文章目录Qt 多线程操作2.线程类QThread3.多线程使用：方式一4.多线程使用：方式二5.Qt 线程池的使用 Qt 多线程操作 应用程序在某些情况下需要处理比较复杂的逻辑， 如果只有一个线程去处理，就会导致窗口卡顿，无法处理用户的相关操作。这种情况下就需要使用多线程，其中一个线程处理窗口事件，其他线程进行逻辑运算，多个线程各司其职，不仅可以提高用户体验还可以提升程序的执行效率。 Qt中使用多线程需要注意： Qt的默认线程为窗口线程（主线程）：负责窗口事件处理或窗口控件数据的更新； 子线程负责后台的业
并发编程之多线程基础.docx
07-05
### 并发编程之多线程基础 #### 1. 进程与线程的概念及其区别 - **进程**：可以将进程理解为一个正在执行的应用程序，它是系统进行资源分配和调度的基本单位。每个进程都有自己的独立内存空间，彼此之间不共享数据...
并发编程——线程基础.pdf
06-06
首先，线程的基础概念包括线程的定义、线程的启动和终止以及线程的状态。线程是操作系统能够进行运算调度的最小单位，是指令的集合，是执行路径。一个线程负责执行一个任务，是系统中的一种执行路径。线程不能独立...
linux 线程 基础例程
07-23
本教程通过基础例程帮助初学者理解和掌握Linux线程的创建、管理和同步机制。 1. **线程创建**： 在Linux中，线程的创建通常使用POSIX线程库（pthread），其中`pthread_create()`函数用于创建新线程。参数包括线程...
Educoder–Java高级特性（第四章）- 多线程基础（1）使用线程【笔记+参考代码】
fuhanghang的博客
03-27 1万+
Educoder–Java高级特性（第四章）- 多线程基础（1）使用线程【笔记+参考代码】 第一关 编程要求 请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下： 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下： 1 3 5 7 9； 使用实现Runnab...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 544
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 869
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 537
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 246
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
集合（1）
supercool7的博客
08-12 821
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 932
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值