C++ 线程池的封装实现

最新推荐文章于 2024-06-03 16:23:52 发布
最新推荐文章于 2024-06-03 16:23:52 发布
阅读量3.4w 收藏 40
点赞数 6
分类专栏： UNIX/LINUX C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/turkeyzhou/article/details/8755976
版权
 为了充分利用多核的优势，我们利用多线程来进行任务处理，但线程也同样不能滥用，会带来一下几个问题：
1）线程本身存在开销，系统必须为每个线程分配如栈，TLS（线程局部存储），寄存器等。
2）线程管理会给系统带来开销，context切换同样会给系统带来成本。
3）线程本身是可以重用的资源，不需要每次都进行初始化。

所以往往在使用中，我们无需把线程与task任务进行一对一对应，只需要预先初始化有限的线程个数来处理无限的task任务即可，线程池应运而生，原理也就是如此。

线程池具体构造如下：



主要含有三个队列
  • 工作队列
  • 工作线程队列
  • 忙碌线程队列
工作队列是一个阻塞队列，任务（仿函数）任务不算被push进来（notify阻塞获取的工作线程），工作线程队列（一直不变）则从该队列中获取任务执行（wait获取，当任务队列为空时阻塞等待通知），如果获取到任务，则将线程会进入忙碌线程队列中，执行任务的仿函数，当工作完成，重新移出工作线程队列。


定义线程池专属异常：
struct  TC_ThreadPool_Exception  :  public  TC_Exception
{
    TC_ThreadPool_Exception( const  string &buffer) : TC_Exception(buffer){};
    TC_ThreadPool_Exception( const  string &buffer,  int  err) : TC_Exception(buffer, err){};
    ~TC_ThreadPool_Exception ()  throw  (){};
};


/**
 * @brief 用通线程池类, 与tc_functor, tc_functorwrapper配合使用.
 * 
 * 使用方式说明:
 * 1 采用tc_functorwrapper封装一个调用
 * 2 用tc_threadpool对调用进行执行
 * 具体示例代码请参见:test/test_tc_thread_pool.cpp
 */

/**线程池本身继承自锁，可以帮助锁定**/
class  TC_ThreadPool  :  public  TC_ThreadLock
{
public :

     /**
     * @brief 构造函数
     *
     */
    TC_ThreadPool ();

     /**
     * @brief 析构, 会停止所有线程
     */
    ~TC_ThreadPool ();

     /**
      * @brief 初始化.
      * 
     * @param num 工作线程个数
     */
     void  init(size_t num);

     /**
     * @brief 获取线程个数.
     *
     * @return size_t 线程个数
     */
    size_t getThreadNum()   {  Lock  sync(*  this );  return  _jobthread . size(); }

     /**
     * @brief 获取线程池的任务数( exec添加进去的).
     *
     * @return size_t 线程池的任务数
     */
    size_t getJobNum()     {  return  _jobqueue . size(); }

     /**
     * @brief 停止所有线程
     */
     void  stop();

     /**
     * @brief 启动所有线程
     */
     void  start();

     /**
      * @brief 启动所有线程并, 执行初始化对象.
      * 
     * @param ParentFunctor
     * @param tf
     */
     template < class  ParentFunctor >
     void  start( const  TC_FunctorWrapper <  ParentFunctor > &tf)
    {
         for (size_t i = 0; i <  _jobthread  .size(); i++)
        {
             _startqueue . push_back( new  TC_FunctorWrapper < ParentFunctor  >(tf));
        }

        start();
    }

     /**
      * @brief 添加对象到线程池执行，该函数马上返回，
      *     线程池的线程执行对象
      */
     template < class  ParentFunctor >
      void  exec( const  TC_FunctorWrapper <  ParentFunctor > &tf)
    {
         _jobqueue .push_back( new  TC_FunctorWrapper < ParentFunctor  >(tf));
    }

     /**
     * @brief 等待所有工作全部结束(队列无任务, 无空闲线程).
     *
     * @param millsecond 等待的时间( ms), -1:永远等待
      * @return            true, 所有工作都处理完毕
      *                        false,超时退出
     */
     bool  waitForAllDone( int  millsecond = -1);

public :

     /**
     * @brief 线程数据基类,所有线程的私有数据继承于该类
     */
     class  ThreadData
    {
     public :
         /**
         * @brief 构造
         */
        ThreadData(){};
         /**
         * @brief 析够
         */
         virtual  ~ThreadData(){};

         /**
            * @brief 生成数据.
            * 
            * @ param T
         * @return ThreadData*
         */
         template < typename  T >
         static  T * makeThreadData()
        {
             return  new  T ;
        }
    };

     /**
      * @brief 设置线程数据.
      * 
     * @param p 线程数据
     */
     static  void  setThreadData( ThreadData  *p);

     /**
     * @brief 获取线程数据.
     *
     * @return ThreadData* 线程数据
     */
     static  ThreadData * getThreadData();

     /**
      * @brief 设置线程数据, key需要自己维护.
      * 
     * @param pkey 线程私有数据key
     * @param p    线程指针
     */
     static  void  setThreadData(pthread_key_t pkey,  ThreadData  *p);

     /**
      * @brief 获取线程数据, key需要自己维护.
      * 
     * @param pkey 线程私有数据key
     * @return     指向线程的ThreadData*指针
     */
     static  ThreadData * getThreadData(pthread_key_t pkey);

protected :

     /**
      * @brief 释放资源.
      * 
     * @param p
     */
     static  void  destructor( void  *p);

     /**
     * @brief 初始化key
     */
     class  KeyInitialize
    {
     public :
         /**
         * @brief 初始化key
         */
        KeyInitialize()
        {
             int  ret = pthread_key_create(& TC_ThreadPool :: g_key ,  TC_ThreadPool ::destructor);
             if (ret != 0)
            {
                 throw  TC_ThreadPool_Exception ( "[TC_ThreadPool::KeyInitialize] pthread_key_create error" , ret);
            }
        }

         /**
         * @brief 释放key
         */
        ~KeyInitialize()
        {
            pthread_key_delete( TC_ThreadPool :: g_key );
        }
    };

     /**
     * @brief 初始化key的控制
     */
     static  KeyInitialize  g_key_initialize ;

     /**
     * @brief 数据key
     */
     static  pthread_key_t  g_key ;

protected :
     /**
     * @brief 线程池中的工作线程
     */
     class  ThreadWorker  :  public  TC_Thread
    {
     public :
         /**
            * @brief 工作线程构造函数.
            * 
         * @ param tpool
         */
        ThreadWorker( TC_ThreadPool  *tpool);

         /**
         * @brief 通知工作线程结束
         */
         void  terminate();

     protected :
         /**
         * @brief 运行
         */
         virtual  void  run();

     protected :
         /**
         * 线程池指针
         */
         TC_ThreadPool    *  _tpool ;

         /**
         * 是否结束线程
         */
         bool              _bTerminate ;
    };

protected :

     /**
     * @brief 清除
     */
     void  clear();

     /**
     * @brief 获取任务, 如果没有任务, 则为NULL.
     *
     * @return TC_FunctorWrapperInterface*
     */
     TC_FunctorWrapperInterface  * get( ThreadWorker  *ptw);

     /**
     * @brief 获取启动任务.
     *
     * @return TC_FunctorWrapperInterface*
     */
     TC_FunctorWrapperInterface  * get();

     /**
      * @brief 空闲了一个线程.
      * 
     * @param ptw
     */
     void  idle( ThreadWorker  *ptw);

     /**
     * @brief 通知等待在任务队列上的工作线程醒来
     */
     void  notifyT();

     /**
     * @brief 是否处理结束.
     *
     * @return bool
     */
     bool  finish();

     /**
     * @brief 线程退出时调用
     */
     void  exit();

     friend  class  ThreadWorker ;
protected :

     /**
     * 任务队列
     */
     TC_ThreadQueue <  TC_FunctorWrapperInterface *>  _jobqueue ;

     /**
     * 启动任务
     */
     TC_ThreadQueue <  TC_FunctorWrapperInterface *>  _startqueue ;

     /**
     * 工作线程
     */
    std::vector< ThreadWorker  *>                   _jobthread ;

     /**
     * 繁忙线程
     */
    std::set< ThreadWorker  *>                      _busthread ;

     /**
     * 任务队列的锁
     */
     TC_ThreadLock                                 _tmutex ;

      /**
      * 是否所有任务都执行完毕
      */
      bool                                          _bAllDone ;
};



工作线程设计如下：
TC_ThreadPool ::ThreadWorker::ThreadWorker( TC_ThreadPool  *tpool)
:  _tpool  (tpool)
,  _bTerminate  (  false )
{
}

void  TC_ThreadPool ::ThreadWorker::terminate()
{
     _bTerminate  =  true ;
     _tpool ->notifyT();
}

void  TC_ThreadPool ::ThreadWorker::run()
{
     //调用初始化部分
     TC_FunctorWrapperInterface  *pst =  _tpool ->get();
     if (pst)
    {
         try
        {
            (*pst)();
        }
         catch  ( ... )
        {
        }
         delete  pst;
        pst = NULL;
    }

     //调用处理部分
     while  (!  _bTerminate )
    {
         TC_FunctorWrapperInterface  *pfw =  _tpool ->get(  this );
         if (pfw != NULL)
        {
            auto_ptr<  TC_FunctorWrapperInterface > apfw(pfw);

             try
            {
                (*pfw)();
            }
             catch  ( ... )
            {
            }

             _tpool ->idle(  this );
        }
    }

     //结束
     _tpool ->exit();
}

每个工作线程在刚开始时都会执行一下初始化操作，并进入一个无限循环的部分 //调用处理部分
     while  (!  _bTerminate )
    {
         TC_FunctorWrapperInterface  *pfw =  _tpool ->get(  this );
         if (pfw != NULL)
        {
            auto_ptr<  TC_FunctorWrapperInterface > apfw(pfw);

             try
            {
                (*pfw)();
            }
             catch  ( ... )
            {
            }

             _tpool ->idle(  this );
        }
    }
该工作主要是无限的从线程池的工作队列中获取任务并执行，如果成功获取任务，则会将线程移进忙碌队列：

TC_FunctorWrapperInterface  *TC_ThreadPool:: get( ThreadWorker  *ptw)
{

     TC_FunctorWrapperInterface  *pFunctorWrapper = NULL;
     if (!  _jobqueue . pop_front(pFunctorWrapper, 1000))
    {
         return  NULL;
    }

     {
             Lock  sync(  _tmutex );
          _busthread . insert(ptw);
    }
     return  pFunctorWrapper;
}

执行完，移回工作线程队列： _tpool ->idle(  this );

void  TC_ThreadPool:: idle( ThreadWorker  *ptw)
{
     Lock  sync(  _tmutex );
     _busthread . erase(ptw);

     //无繁忙线程, 通知等待在线程池结束的线程醒过来
     if (  _busthread . empty())
    {
         _bAllDone  =  true ;
         _tmutex .notifyAll();
    }
}


此处jobThread队列初始化后不会改变（因为没有实现自增长功能），所以非线程安全的vector队列即可，busthread的忙碌线程队列会被移进移出，但是操作会自带 Lock  sync(  _tmutex )，该互斥量是线程池本身继承的，所以是共有的，也无需另外使用线程安全的 TC_ThreadQueue， 使用vector即可。

TC_ThreadPool::  idle 中的

     if (  _busthread . empty())
    {
         _bAllDone  =  true ;
         _tmutex .notifyAll();
    }

主要用于当线程池工作起来后的 waitForAllDone 方法:

bool  TC_ThreadPool:: waitForAllDone(  int  millsecond)
{
     Lock  sync(  _tmutex );

start1:
     //任务队列和繁忙线程都是空的
     if  (finish())
    {
         return   true ;
    }

     //永远等待
     if (millsecond < 0)
    {
         _tmutex .timedWait(1000);
         goto  start1;
    }

     int64_t  iNow =  TC_Common :: now2ms();
     int  m       = millsecond;
start2:

     bool  b =  _tmutex .timedWait(millsecond);
     //完成处理了
     if (finish())
    {
         return   true ;
    }

     if (!b)
    {
         return   false ;
    }

    millsecond = max(( int64_t  )0, m  - ( TC_Common  ::now2ms() - iNow));
     goto  start2;

     return   false ;
}

_tmutex .timedWait(millsecond)方法唤醒。反复判断是否所有的工作是否完成：

bool  TC_ThreadPool:: finish()
{
     return   _startqueue . empty() &&  _jobqueue  .empty() &&  _busthread . empty() &&  _bAllDone ;
}


整体cpp实现如下：

TC_ThreadPool  :: KeyInitialize  TC_ThreadPool::g_key_initialize ;
pthread_key_t  TC_ThreadPool::g_key  ;

void  TC_ThreadPool::destructor(  void  *p)
{
     ThreadData  *ttd = (  ThreadData *)p;
     if (ttd)
    {
         delete  ttd;
    }
}

void  TC_ThreadPool::exit()
{
     TC_ThreadPool ::  ThreadData  *p = getThreadData();
     if (p)
    {
         delete  p;
         int  ret = pthread_setspecific(  g_key , NULL );
         if (ret != 0)
        {
             throw   TC_ThreadPool_Exception  ( "[TC_ThreadPool::setThreadData] pthread_setspecific error" , ret);
        }
    }

     _jobqueue . clear();
}

void  TC_ThreadPool::setThreadData(  TC_ThreadPool ::  ThreadData  *p)
{
     TC_ThreadPool ::  ThreadData  *pOld = getThreadData();
     if (pOld != NULL && pOld != p)
    {
         delete  pOld;
    }

     int  ret = pthread_setspecific(  g_key , (  void  *)p);
     if (ret != 0)
    {
         throw   TC_ThreadPool_Exception  ( "[TC_ThreadPool::setThreadData] pthread_setspecific error" , ret);
    }
}

TC_ThreadPool  :: ThreadData  * TC_ThreadPool::getThreadData ()
{
     return  (  ThreadData  *) pthread_getspecific(  g_key );
}

void  TC_ThreadPool::setThreadData( pthread_key_t pkey,  ThreadData  *p)
{
     TC_ThreadPool ::  ThreadData  *pOld = getThreadData(pkey);
     if (pOld != NULL && pOld != p)
    {
         delete  pOld;
    }

     int  ret = pthread_setspecific(pkey, (  void  *)p);
     if (ret != 0)
    {
         throw   TC_ThreadPool_Exception  ( "[TC_ThreadPool::setThreadData] pthread_setspecific error" , ret);
    }
}

TC_ThreadPool  :: ThreadData  * TC_ThreadPool::getThreadData( pthread_key_t pkey)
{
     return  (  ThreadData  *) pthread_getspecific(pkey);
}

TC_ThreadPool::TC_ThreadPool()
:  _bAllDone  (  true )
{
}

TC_ThreadPool::~TC_ThreadPool()
{
    stop();
    clear();
}

void  TC_ThreadPool::clear()
{
    std::vector<  ThreadWorker  *>::iterator it =  _jobthread . begin();
     while (it !=  _jobthread . end())
    {
         delete  (*it);
        ++it;
    }

     _jobthread . clear();
     _busthread . clear();
}

void  TC_ThreadPool::init( size_t num)
{
    stop();

     Lock  sync(*  this );

    clear();

     for ( size_t i = 0; i < num; i++)
    {
         _jobthread . push_back(  new  ThreadWorker(  this ));
    }
}

void  TC_ThreadPool::stop()
{
     Lock  sync(*  this );

    std::vector<  ThreadWorker  *>::iterator it =  _jobthread . begin();
     while (it !=  _jobthread . end())
    {
         if  ((*it)-> isAlive())
        {
            (*it)-> terminate();
            (*it)-> getThreadControl().join ();
        }
        ++it;
    }
     _bAllDone  =  true ;
}

void  TC_ThreadPool::start()
{
     Lock  sync(*  this );

    std::vector<  ThreadWorker  *>::iterator it =  _jobthread . begin();
     while (it !=  _jobthread . end())
    {
        (*it)-> start();
        ++it;
    }
     _bAllDone  =  false ;
}

bool  TC_ThreadPool:: finish()
{
     return   _startqueue . empty() &&  _jobqueue  .empty() &&  _busthread . empty() &&  _bAllDone ;
}

bool  TC_ThreadPool::waitForAllDone(  int  millsecond)
{
     Lock  sync(  _tmutex );

start1:
     //任务队列和繁忙线程都是空的
     if  (finish ())
    {
         return   true ;
    }

     //永远等待
     if (millsecond < 0)
    {
         _tmutex .timedWait(1000);
         goto  start1;
    }

     int64_t  iNow =  TC_Common :: now2ms();
     int  m       = millsecond;
start2:

     bool  b =  _tmutex .timedWait(millsecond);
     //完成处理了
     if (finish ())
    {
         return   true ;
    }

     if (!b)
    {
         return   false ;
    }

    millsecond = max(( int64_t  )0, m  - ( TC_Common  ::now2ms() - iNow));
     goto  start2;

     return   false ;
}

TC_FunctorWrapperInterface  *TC_ThreadPool::get(  ThreadWorker  *ptw)
{

     TC_FunctorWrapperInterface  *pFunctorWrapper = NULL;
     if (!  _jobqueue . pop_front(pFunctorWrapper, 1000))
    {
         return  NULL;
    }

     {
             Lock  sync(  _tmutex );
          _busthread . insert(ptw);
    }
     return  pFunctorWrapper;
}

TC_FunctorWrapperInterface  *TC_ThreadPool::get()
{
     TC_FunctorWrapperInterface  *pFunctorWrapper = NULL;
     if (!  _startqueue . pop_front(pFunctorWrapper))
    {
         return  NULL;
    }

     return  pFunctorWrapper;
}

void  TC_ThreadPool::idle(  ThreadWorker  *ptw)
{
     Lock  sync(  _tmutex );
     _busthread . erase(ptw);

     //无繁忙线程, 通知等待在线程池结束的线程醒过来
     if (  _busthread . empty())
    {
             _bAllDone  =  true ;
         _tmutex .notifyAll();
    }
}

void  TC_ThreadPool::notifyT()
{
     _jobqueue . notifyT();
}
  


turkeyzhou
关注
  • 6
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c++线程池实现方法
09-03
在提供的代码片段中，我们可以看到一个简单的C++线程池实现，主要包括`locker.h`（锁类）、`task_list.h`（任务列表类）和`task_list.cpp`（任务列表类的实现）。 1. **线程安全的数据结构**： - `locker.h`定义了...
用C++封装线程池
天涯路的专栏
11-20 1210
先上代码，代码来自GitHub。这段代码用了大量C++ 11新特性，并且非常晦涩难懂，接下来会对每个细节逐个解释。 ThreadPool.h #ifndef THREAD_POOL_H #define THREAD_POOL_H #include <vector> #include <queue> #include <memory> #include <thread> #include <mutex> #include <condit
c++ 基础13、线程池封装2
Mr-zhou先生
10-08 220
线程池封装2
C++实现线程池详解
最新发布
威桑的博客
06-03 560
Windows 下 C++ 实现线程池
2024年Go最全【LeetCode刷题日记】507(1)，Golang初级开发是如何一步步成为高级开发
2401_84924721的博客
05-15 278
链接：https://leetcode-cn.com/problems/perfect-number。著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。1, 2, 4, 7, 和 14 是 28 的所有正因子。解释：28 = 1 + 2 + 4 + 7 + 14。来源：力扣（LeetCode）输入：num = 8128。输入：num = 496。输入：num = 6。输入：num = 2。
企业级跨平台C++线程池实现
12-27
在企业级软件开发中，跨平台的C++线程池是一种高效、可靠的任务调度机制，它允许多个任务并行执行，充分利用多核处理器的计算能力。线程池的实现通常涉及多线程编程，线程同步，以及任务管理等核心概念。下面将详细...
C++线程池实现 vc2015编译
12-24
在这个项目中，我们看到一个用于VC2015编译环境的C++线程池实现。 首先，`stdafx.cpp`和`stdafx.h`是Visual Studio项目中的标准预编译头文件，通常包含常用的库引用和预处理器定义，以提高编译速度。`targetver.h`...
C++ 线程池实现原理1
08-04
理解线程池的实现原理对于任何C++开发者来说都是非常重要的，它可以帮助开发者更好地设计并发程序，提升软件性能。在实际开发中，可以利用标准库如`std::thread`和`std::async`，或者第三方库如`boost.asio`或`...
C++实现线程池详解（基于boost源码以及封装等线程池）
10-15
三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、后进先出、优先级代码示例 五、看看人家线程池怎么写的 - 要理解精髓 六、线程池应用...
线程池c++实现
08-03
线程池 c++
c++ 线程池 即用版
12-21
用c++ 实现的线程池工程，可直接使用，其中线程数目可根据空闲情况自增减，并且实现线程跟任务无关联。
C/C++ 线程池的简单封装
SupriseF的博客
10-08 354
**C/C++ 线程池的简单封装 最近在搭建一个服务器，打算把线程池应用进去，根据老师课上所讲和网上前辈们提供的资料对线程池有了以下总结：** 一、线程的创建需要内存资源，线程的创建和销毁需要时间资源 二、线程池作用： 如果项目需要频繁的创建线程来处理任务，那么CPU资源会在线程创建和销毁上浪费许多，所以我们可以先把一定量的线程先创建好并且让它们在没任务的情况下陷入睡眠，有任务时再被唤醒来处理任务； 三、线程池组成部分： （1） 线程池管理器： 对线程进行创建与管理 （2） 工作线程： 线程池中的线程 （3
linux c++下将pthread封装成threadpool（线程池）
sumkee911‘s coding
12-09 3728
threadpool主要有4個函數: 1.init() 初始化線程池，線程數量自己定 2.destroy() 銷燬線程池，所有線程會被立即銷燬 3.add_event() 增加事件到線程池中，以及喚醒線程作處理 4.thread_process() 這個函數識static的，就是用來做線程的回調函數，線程們就是在這裏等待喚醒處理事件 threadpool.h /* * Name:
线程池的原理及C++线程池的封装实现
amoscykl的博客
10-08 4375
线程池原理介绍 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。 线程池的组成部分： 线程池管理器（ThreadPoolManager）:用于创建并管理线程池 工作线程（WorkThread）: 线程池中线程 任务接口（Task）:每个任务必须实现的接口...
C++ 线程池
热门推荐
qq_34771252的博客
05-18 2万+
2019-05-17 20:16:52 原文链接 C++线程池 参考链接： 基于C++11实现线程池的工作原理;c++简单线程池实现 基础概念 线程池: 当进行并行的任务作业操作时，线程的建立与销毁的开销是，阻碍性能进步的关键，因此线程池，由此产生。使用多个线程，无限制循环等待队列，进行计算和操作。帮助快速降低和减少性能损耗。 线程池的组成 线程池管理器：初始化和创建线程，启动和停止线程，调...
C++封装POSIX 线程库（六）线程池
上善若水
05-24 1887
线程池有两个主要组件: 1.threads 2.blocking queue 解决的问题是线程创建与销毁带来的开销和通过线程池实现伪异步 过程类似于简单的生产者消费者问题(详见wiki)Blocking Queue对应用户添加任务CallBack和线程拿任务执行两个操作,因此需要两个条件变量和一个互斥锁如果把用户添加任务比做生产者,线程拿任务比做消费者..那么需要两个条件变量就解决了
线程池C++封装
二进制君
06-13 539
待写
c++线程池实现tcp服务器
07-01
当有新的连接请求时，将其封装为一个任务，并提交给线程池进行处理。可以使用execute()或submit()方法来提交任务。 4. 在任务中，首先需要通过Socket对象获取客户端的输入流和输出流，用于与客户端进行通信。可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值