Linux - C - 多线程

最新推荐文章于 2024-03-22 23:44:26 发布
置顶 最新推荐文章于 2024-03-22 23:44:26 发布
阅读量237 收藏 6
点赞数 3
分类专栏： C ubuntu 文章标签： linux c++ 多线程
Zero
本文链接：https://blog.csdn.net/weixin_43707799/article/details/107688445
版权
ubuntu 同时被 2 个专栏收录
7 篇文章 3 订阅
订阅专栏
C
1 篇文章 0 订阅
订阅专栏
  • 线程标识符：typedef unsigned long int pthread_t;

创建线程

  • pthread_create 函数：

     头文件：#include <pthread.h>
 
 原函数：pthread_create(pthread *restrict tid
 		       		   const pthread_attr_t *restrict attr,
 		       		   void *(*start_routine)(void *),
 		       		   void *restrict arg)
 		       		   
 参数一：线程标识符，新线程ID，创建一个进程。如果成功则新线程的ID回填充到tidp的内存。
 参数二：设置线程属性（调度策略，继承性，分高性），默认值NULL
 参数三：回调函数（新线程要执行的函数），一旦线程被创建就会执行
 参数四：回调函数的参数，必须通过把引用作为指针强制转换为 void 类型进行传递。如果没有传递参数，则使用 NULL。
 
 返回值：成功返回0，失败则返回错误码。
 注：创建线程成功后，新创建的线程则运行参数三和参数四，原来的线程则继续运行下一行代码。

结束线程

  • pthread_exit 函数：

     原函数：extern void pthread_exit P ((void *__retval)) __attribute ((noreturn));
 
 只有一个参数：函数的返回代码。
 
 显式的退出一个线程。通常情况，在线程完成后，不再调用时，调用此函数。
 如果 main() 是在它所创建的线程之前结束，并通过 pthread_exit() 退出，那么其他线程将继续执行。否则，它们将在 main() 结束时自动被终止。

线程等待

  • pthread_join 函数：

     原函数：int pthread_join(pthread_t tid,void ** rval);
 
 参数一：指定线程的 id，被等待的线程标识符
 参数二：一个用户定义的指针，指定线程的返回码，如果线程被取消，那么 rval被置为 PTHREAD_CANCELED。它可以用来存储被等待线程的返回值。
 
 返回值：成功会返回0，失败返回错误码
 这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。
 注：*调用此函数会使指定的线程处于分离的状态，如果指定线程已经处于分离状态，那么调用就会失败。
 	 *一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用此函数的线程则返回错误代码 ESRCH。

在这里插入图片描述

  • 例1：
#include <pthread.h>
#include <stdio.h>
#define NUM_THREADS 5      //线程个数

void *say_hello(void *args)
{
    printf("Hello！\n");
}

int main()
{
    //定义线程的 id 变量，多个变量使用数组
    pthread_t tids[NUM_THREADS];
    for (int i = 0; i < NUM_THREADS; ++i) {
        //参数依次是：创建的线程id，线程参数，调用的函数，传入的函数参数
        int ret = pthread_create(&tids[i], NULL, say_hello, NULL);
        if (ret != 0) {
            printf("pthread_create error: error_code = %d\n", ret);
        }
    }

    //等各个线程退出后，进程才结束，否则进程强制结束了，线程可能还没反应过来；
    pthread_exit(NULL);
}

执行结果：

Hello！
Hello！
Hello！
Hello！
Hello！

在这里插入图片描述

  • 例2：
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include <sys/types.h>

void print_id(char *s)
{
	pid_t pid;
	pthread_t tid;
	
	pid = getpid();
	tid = pthread_self();

	printf("%s pid is %u, tid is 0x%x\n",s,pid,(unsigned int)tid); 
}

void *thread_fun(void *arg)
{
	print_id(arg);
	return (void *)0;
}

int main()
{
	pthread_t ntid;
	int err;

	err = pthread_create(&ntid,NULL,thread_fun,"new thread: ");
	if(err!=0)
	{
		printf("create new thread fail\n");
		return 0;
	}
	print_id("main thread:");
	sleep(2);
	return 0;
}

执行结果：

main thread: pid is 4857, tid is 0xfd6b9700
new thread: pid is 4857, tid is 0xfcecb700

在这里插入图片描述

  • 例3：
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

// 线程一
void thread_1(void) {
    int i = 0;
    for(i = 0; i <= 6; i++) {
        printf("This is a pthread_1.\n");
        if(i == 2) {
            pthread_exit(0);
        }
        sleep(1);
    }
}

// 线程二
void thread_2(void) {
    int i;
    for(i = 0; i < 3; i++) {
        printf("This is a pthread_2.\n");
    }
    pthread_exit(0);
}

int main(void) {
    pthread_t id_1, id_2;
    int ret;

    /*创建线程一*/
    ret=pthread_create(&id_1, NULL, (void  *) thread_1, NULL);
    if(ret != 0) {
        printf("Create pthread error!\n");
        return -1;
    }

    /*创建线程二*/
    ret=pthread_create(&id_2, NULL, (void  *) thread_2, NULL);
    if(ret != 0) {
        printf("Create pthread error!\n");
        return -1;
    }

    /*等待线程结束*/
    pthread_join(id_1, NULL);
    pthread_join(id_2, NULL);
    return 0;
}

执行结果：

This is a pthread1
This is a pthead2
This is a pthead2
This is a pthead2
This is a pthread1
This is a pthread1

在这里插入图片描述

在这里插入图片描述

互斥量（锁）

互斥量本质就是锁，访问共享资源前，对互斥量加锁，访问完成后解锁。
另一种解释：在访问临界资源时，通过互斥，限制同一时刻最多只能有一个线程可以获取临界资源。
、
目的： 为了让线程访问数据不产生冲突，使得同一时刻只有一个线程可以访问变量，其他线程无法进行访问并阻塞，数据得到同步。
、
逻辑： 如果访问临街资源发现没有其他线程上锁，就上锁，获取临界资源，期间如果其他线程执行到互斥锁发现已锁住，则线程挂起等待解锁，当前线程访问完临界资源后，解锁并唤醒其他被该互斥锁挂起的线程，等待再次被调度执行。
、
缺点： 要么加锁要么不加锁，而且同一时刻只允许一个线程对其加锁。
、
线程同步： 当多个线程共享相同的内存时，其中一个线程修改变量，其他线程也可以读取或者修改这个修改后的变量。
、
互斥量用 pthread_mutex_t类型的数据表示
简单流程：初始化锁 —> 上锁 —> 解锁 —> 销毁锁

  • 静态初始化互斥量

     pthread_mutex_t theMutex;
 pthread_mutex_t result = PTHREAD_MUTEX_INITIALIZER;

  • 动态初始化互斥量

     原函数：int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr)
 
 参数一：要初始化的互斥量
 参数二：互斥量的属性（可以写NULL）
 
 返回值：成功返回0，失败返回错误码

  • 加锁

     原函数：int pthread_mutex_lock(pthread_mutex_t *mutex)
 
 只有一个参数：要加锁的互斥量
 
 返回值：成功返回0，失败返回错误码
 注：如果互斥量已经被锁住，那么会导致该线程阻塞。

  • 尝试加锁

     原函数：int pthread_mutex_trylock(pthread_mutex_t *mutex)
 
 只有一个参数：要加锁的互斥量
 
 返回值：成功返回0，失败返回错误码
 注：如果互斥量已经被锁住，不会导致线程阻塞。
    与 pthread_mutex_lock不一样的是：当锁已经在使用的时候，返回为EBUSY，而不是挂起等待。

  • 解锁

      原函数：int pthread_mutex_unlock(pthread_mutex_t *mutex)
  
  只有一个参数：要解锁的互斥量
  
  返回值：成功返回0，失败返回错误码
  注：如果一个互斥量没有被锁住（加锁函数和解锁函数要成对出现），否则解锁就会出错。

  • 销毁锁

      原函数：int pthread_mutex_destory(pthread_mutex_t *mutex）
  
  只有一个参数：要销毁的互斥量
  作用：动态分配的互斥量释放内存

在这里插入图片描述

举个栗子：

  • 不上锁，线程不同步情况
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>

#define LEN 100000
int num = 0;

void* thread_func(void* arg) {
    for (int i = 0; i< LEN; ++i) {
        num += 1;
    }
    return NULL;
}

int main() {
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, (void*)thread_func, NULL);
    pthread_create(&tid2, NULL, (void*)thread_func, NULL);

    char* rev = NULL;
    pthread_join(tid1, (void *)&rev);
    pthread_join(tid2, (void *)&rev);

    printf("correct result=%d, wrong result=%d.\n", 2*LEN, num);
    return 0;
}

执行结果：

correct result=200000, wrong result=106860

在这里插入图片描述

  • 上锁，线程同步
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>

#define LEN 100000
int num = 0;

void* thread_func(void* arg) {
    pthread_mutex_t* p_mutex = (pthread_mutex_t*)arg;
    for (int i = 0; i< LEN; ++i) {
        pthread_mutex_lock(p_mutex);
        num += 1;
        pthread_mutex_unlock(p_mutex);
    } 
    return NULL;
}

int main() {
    pthread_mutex_t m_mutex;
    pthread_mutex_init(&m_mutex, NULL);

    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, (void*)thread_func, (void*)&m_mutex);
    pthread_create(&tid2, NULL, (void*)thread_func, (void*)&m_mutex);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    pthread_mutex_destroy(&m_mutex);

    printf("correct result=%d, result=%d.\n", 2*LEN, num);
    return 0;
}

执行结果：

correct result=200000, result=200000

一些补充：
一、锁保护的并不是我们的共享变量（或者说是共享内存），对于共享的内存而言，用户是无法直接对其保护的，因为那是物理内存，无法阻止其他程序的代码访问。事实上，锁之所以对关键区域进行了保护，是因为所有线程都遵循了一个规则，那就是在进入关键区域钱加同一把锁，在退出关键区域前释放同一把锁。
、
二、加锁是会带来额外的开销的，加锁的代码其运行速度，明显比不加锁的要慢一些，所以，在使用锁的时候，要合理，在不需要对关键区域进行保护的场景下，我们便不要画蛇添足，为其加锁了

在这里插入图片描述

读写互斥量（读写锁）

概述： 与互斥量类似，相关函数都差不多，另外一种线程同步机制，只不过比互斥量具有更高的并行性。
、
运用场景： 适用于对数据结构，读的次数远远大于写的次数
、
与互斥量不同点：

  1. 互斥量会把试图进入已保护的临界区的线程都阻塞；然而读写锁会视当前进入临界区的线程和请求进入临界区的线程的属性来判断是否允许线程进入。
  2. 相对互斥量只有加锁和不加锁两种状态，读写锁有三种状态：读模式下的加锁，写模式下的加锁，不加锁。

、
规则：

  1. 一次只有一个线程可以占有写模式读写锁，但是可以有多个线程同时占有读模式的读写锁。
  2. 当读写锁处于写加锁状态时，所有试图对这个锁加锁的线程都将被阻塞。
  3. 当读写锁处于读加锁状态时，所有试图以读模式对这个锁访问的线程都将得到访问权，而以写模式对这个锁访问的线程都将被阻塞，需要等到所有读线程释放锁写模式线程才能得到访问权。
  4. 如果读写锁当前处于读模式，有线程请求写模式，那么接下来的读模式请求都将被阻塞，这样可以避免读模式锁长期被占用，而写模式请求得不到满足。
  5. 读写锁在使用之前必须初始化，在释放底层内存之前必须被销毁。

  • 静态初始化读写锁

      pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

  • 动态初始化读写锁

      原函数：int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr)
  
  参数一： 要初始化的锁
  参数二：attr，锁属性（可写NULL）
  
  返回值：成功返回0，失败返回错误码

  • 读模式加锁

      原函数：int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock)
  
  只有一个参数：要加锁的锁
  
  返回值：成功返回0，失败返回错误码

  • 尝试读模式加锁

      原函数：int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock)
  
  只有一个参数：要加锁的锁
  
  返回值：：成功返回0，失败返回错误码

  • 写模式加锁

      原函数：int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)
  
  只有一个参数：要加锁的锁
  
  返回值：成功返回0，失败返回错误码

  • 尝试写模式加锁

      原函数：int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock)
  
  只有一个参数：要加锁的锁
  
  返回值：成功返回0，失败返回错误码

  • 解锁

      原函数：int pthread_rwlock_unlock(pthread_rwlock_t *rwlock)
  
  只有一个参数：要解锁的锁
  
  返回值：成功返回0，失败返回错误码

  • 读写锁销毁

      原函数：int pthread_rwlock_destroy(pthread_rwlock_t *rwlock)
  
  只有一个参数：要销毁的锁
  
  返回值：成功返回0，失败返回错误码

在这里插入图片描述

  • 例子1：
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
 
//定义一个全局锁
pthread_rwlock_t rwlock;
int num=0;
void *thread_fun1(void *arg)
{
        //读加锁        
//      pthread_rwlock_rdlock(&rwlock);
        //写加锁
        pthread_rwlock_wrlock(&rwlock);
        printf("the first thread print %d\n",num);
        sleep(5);
 
        printf("the first thread over\n");
        //解锁
        pthread_rwlock_unlock(&rwlock);
 
        return (void *)1;
}
void *thread_fun2(void *arg)
{
        //读加锁        
//      pthread_rwlock_rdlock(&rwlock);
        //写加锁
        pthread_rwlock_wrlock(&rwlock);
        printf("the second thread print %d\n",num);
        sleep(5);
 
        printf("the second thread over\n");
        //解锁
        pthread_rwlock_unlock(&rwlock);
 
        return (void *)2;
}
int main()
{
        pthread_t tid1,tid2;
        int err;
        //初始化读写锁
        err=pthread_rwlock_init(&rwlock,NULL);
        if(err != 0)
        {
                printf("init rwlock failure\n");
                return 1;
        }
        //创建新的线程
        err=pthread_create(&tid1,NULL,thread_fun1,NULL);
        if(err != 0)
        {
                printf("create new firest thread failure\n");
                return 1;
        }
        err=pthread_create(&tid2,NULL,thread_fun2,NULL);
        if(err != 0)
        {
                printf("create new second thread failure\n");
                return 1;
        }
        //等待新线程执行完毕
        pthread_join(tid1,NULL);
        pthread_join(tid2,NULL);
        //读写锁的销毁
        pthread_rwlock_destroy(&rwlock);
        return 0;
}

运行结果：

the first thread print 0
the first thread over
the second thread print 0
the second thread over

在这里插入图片描述

  • 例子2：
#include <iostream>
#include <cstdlib>
 
#include <unistd.h>
#include <pthread.h>
 
using namespace std;
 
struct{
    pthread_rwlock_t rwlock;
    int product;
}sharedData = {PTHREAD_RWLOCK_INITIALIZER, 0};
 
void * produce(void *ptr)
{
    for (int i = 0; i < 5; ++i)
    {
        pthread_rwlock_wrlock(&sharedData.rwlock);
        sharedData.product = i;
        pthread_rwlock_unlock(&sharedData.rwlock);
 
        sleep(1);
    }
}
 
void * consume1(void *ptr)
{
    for (int i = 0; i < 5;)
    {
        pthread_rwlock_rdlock(&sharedData.rwlock);
        cout<<"consume1:"<<sharedData.product<<endl;
        pthread_rwlock_unlock(&sharedData.rwlock);
 
        ++i;
        sleep(1);
    }
}
 
void * consume2(void *ptr)
{
    for (int i = 0; i < 5;)
    {
        pthread_rwlock_rdlock(&sharedData.rwlock);
        cout<<"consume2:"<<sharedData.product<<endl;
        pthread_rwlock_unlock(&sharedData.rwlock);
 
        ++i;
        sleep(1);
    }
}
 
int main()
{
    pthread_t tid1, tid2, tid3;
 
    pthread_create(&tid1, NULL, produce, NULL);
    pthread_create(&tid2, NULL, consume1, NULL);
    pthread_create(&tid3, NULL, consume2, NULL);
 
    void *retVal;
 
    pthread_join(tid1, &retVal);
    pthread_join(tid2, &retVal);
    pthread_join(tid3, &retVal);
 
    return 0;
}

执行结果：

consume1:0
consume2:0
consume2:0
consume1:1
consume2:1
consume1:2
consume2:2
consume1:3
consume2:3
consume1:4

待续…

在这里插入图片描述
参考链接：
线程的同步-互斥量、读写锁及条件变量
Linux线程同步之读写锁（rwlock）
Linux线程间同步 —— 读写锁（reader-writer lock）
Linux C —— 多线程
多线程编程（Linux C）
在这里插入图片描述

喜闻樂见
关注
专栏目录
linux C 多线程
数字人生
12-17 473
子线程合入主线程，主线程阻塞。主线程与子线程分离，主线程非阻塞。
linux中c语言实现多线程ping命令
02-08
c语言实现linux下多线程ping命令，可以ping一个网段，格式为./XX 14.215.177.38 14.215.177.40（以百度ip地址为例）
Linux c编程之多线程
szkbsgy的专栏
12-11 1627
我们都知道，运行的程序叫进程，进程是系统资源的最小分配单元。而线程是操作系统能够进行运算调度的最小单位。一个进程默认是有一个线程在运行，也叫单线程进程，也可以启动多个线程，叫做多线程进程。
Linux下c语言多线程编程
m0_47170940的博客
03-30 1万+
创建线程函数pthread_create()和等待线程函数pthread_join()的用法。 注意：在创建线程pthread_create()之前，要先定义线程标识符： pthread_t 自定义线程名； 例子1：创建线程以及等待线程执行完毕。 #include <stdio.h> #include <stdlib.h> #include <pthread.h> //线程要运行的函数，除了函数名myfunc，其他全都是固定的。 void* myfunc() { p
【linux c多线程】线程的创建，线程信息的获取，获取线程返回值
一个追逐梦想的码农
12-26 7999
现代的CPU都是多core处理器，而且在intel处理器中每个core又可以多个processor，形成了多任务并行处理的硬件架构，在服务器端的处理器上架构又有一些不同，传统的采用SMP，也就是对称的多任务处理架构，每个任务都可以对等的访问所有内存，外设等，而如今在ARM系列CPU上，多采用NUMA架构，它将CPU核分了几个组，给每个组的CPU core分配了对应的内存和外设，CPU访问对应的内存和外设时速度最优，跨组访问时性能会降底一些。
【Linux C | 多线程编程】线程的创建、线程ID、线程属性
wkd_007的博客
03-22 2719
本文介绍了线程创建相关的内容，包括pthread_create函数的详细介绍和使用例子，然后依次介绍该函数第一个参数相关的线程ID知识以及第二个参数相关的线程属性知识。读完完整地了解线程的创建。
Linux C中多线程与volatile变量
09-15
在Linux C编程中，多线程编程是一种常见的并发执行方式，允许程序同时执行多个任务，提高系统的效率。然而，多线程环境下数据同步和一致性问题成为了一大挑战。`volatile`关键字在这里起到了关键作用，它确保了在多...
linux-进程和线程
07-26
了解这些基本概念和API后，开发者可以在Linux环境下编写多进程或多线程的C程序，实现高效的并发执行。例如，通过创建子进程处理不同的任务，或在单个进程中使用线程并行执行任务，同时使用互斥锁等同步机制避免数据...
jdk-8u381-linux-x64
07-21
其中最引人注目的变化之一是Lambda表达式，它使得编写简洁的多线程代码成为可能，通过函数式接口和方法引用，可以更轻松地处理集合数据。此外，Java 8还引入了Stream API，这是一种用于处理集合的新方式，支持并行...
操作系统上机-Linux多线程编程
05-18
在操作系统的学习过程中，掌握Linux多线程编程是至关重要的技能之一。Linux作为一款广泛使用的开源操作系统，其强大的系统调用接口和丰富的库函数为开发者提供了实现多线程应用的便利条件。多线程编程允许程序同时...
Linux 的多线程编程的高效开发经验
05-17
本文中我们针对 Linux 上多线程编程的主要特性总结出 5 条经验， 用以改善 Linux 多线程编程的习惯和避免其中的开发 陷阱。
linux C 多线程编程典型实例
08-01
linux c 开发中多线程的典型实例，可在linux平台直接运行，通过实践熟悉理解多线程工作原理。
Linux下的C语言多线程编程
03-24
使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空 间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址 空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。
linux下多进程多线程写文件
10-04
代码目的是比较write和printf多路写性能。首先fork生成子进程，并且在子进程中重定向标准输出；然后在父子进程中各创建10个线程分别利用printf和write进行写操作；最后通过返回值比较两者性能。
【Linux C | 多线程编程】线程的退出(return、pthread_exit、pthread_cancel函数详解)
最新发布
wkd_007的博客
03-22 1333
本文介绍了`线程会终止，进程不会终止` 的三种方式。然后介绍线程退出的两个函数，最后介绍线程退出返回值。
【Linux】多线程的创建、等待、终止
学了就忘是正常现象
03-21 1605
线程控制。
Linux C编程：线程
qq_68639191的博客
03-05 968
进程是程序的一次执行过程也是系统进行资源分配和调度的基本单位，而线程是进程中实施资源调度和分派的基本单位。也就是说一个进程中至少有一个线程（即使不额外使用线程，进程内部也有一个执行线程）。同一进程中的多个线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack，我们称为线程栈），自己的寄存器环境（register context）、自己的线程本地存储（thread-local storage）。
Linux线程（一）—— 多线程（概念、操作）
qq_64353867的博客
10-15 111
多线程（概念、操作）
一文详解C++多线程
热门推荐
非晚非晚的博客
04-25 8万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
Linux下C语言实现多线程编程实例
这个实例展示了Linux下C语言多线程的基本使用，包括线程的创建、同步原语（互斥锁）的使用以及线程的退出。通过学习和理解这个实例，开发者可以进一步掌握Linux多线程编程的基本技巧，为开发更复杂、高效的多线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值