Windows C++ 线程池

最新推荐文章于 2024-07-01 20:36:40 发布
最新推荐文章于 2024-07-01 20:36:40 发布
阅读量1.6k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuguanquan1990/article/details/40661583
版权

        Windows 平台C++ 没什么比较好的官方的线程池，boost里倒是有很方便的线程池，可是为了一个线程池，使用庞大的boost显然不太合适，为此，我在网上找了个demo，然后用C++模板做了些改造，基本上实现了类似boost的threadpool的功能。

首先需要解释的是，以何种方式将线程函数加入队列（我这里用的队列是CList），可以利用类模板和函数模板以及函数指针创建包含该函数的对象，执行时，只需要调用对象中的函数指针即可，这里说明下，因为函数模板在实例化之前是没有任何函数的，因此，自然就不存在指向函数模板的指针。但是可以以另一种方式创建函数模板的指针，即引入类模板。因为类模板实例化之后，其中的函数模板就有意义了。但是，这也出现了个问题，就是类模板中的函数模板无法作为函数指针在类外调用，例如在该头文件对应的cpp文件中调用。因此，不得已需要直接在头文件中定义函数体。

#pragma once

#include "Task.h"
#include <typeinfo>
class ParamTem
{
protected:
	ParamTem(){};
};


template <class ReturnType,class P0=ParamTem,class P1=ParamTem,
class P2=ParamTem,class P3=ParamTem, class P4=ParamTem,
class P5=ParamTem,class P6=ParamTem, class P7=ParamTem>
class CMyTask: public CTask,public ParamTem
{
private:
	typedef ReturnType (*FuncTem)();
	typedef ReturnType (*FuncTem0)(P0 p0);
	typedef ReturnType (*FuncTem1)(P0 p0, P1 p1);
	typedef ReturnType (*FuncTem2)(P0 p0, P1 p1, P2 p2);
	typedef ReturnType (*FuncTem3)(P0 p0, P1 p1, P2 p2,P3 p3);
	typedef ReturnType (*FuncTem4)(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4);
	typedef ReturnType (*FuncTem5)(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5);
	typedef ReturnType (*FuncTem6)(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6);
	typedef ReturnType (*FuncTem7)(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6, P7 p7);
	FuncTem ft;
	FuncTem0 ft0;
	FuncTem1 ft1;
	FuncTem2 ft2;
	FuncTem3 ft3;
	FuncTem4 ft4;
	FuncTem5 ft5;
	FuncTem6 ft6;
	FuncTem7 ft7;
	P0 p0;
	P1 p1;
	P2 p2;
	P3 p3;
	P4 p4;
	P5 p5;
	P6 p6;
	P7 p7;
public:
	CMyTask(FuncTem ft)
	{
		this->ft = ft;
	}
	CMyTask(FuncTem0 ft,P0 p0)
	{
		this->ft0 = ft;
		this->p0 = p0;
	}
	CMyTask(FuncTem1 ft,P0 p0, P1 p1)
	{
		this->ft1 = ft;
		this->p0 = p0;
		this->p1 = p1;
	}
	CMyTask(FuncTem2 ft,P0 p0, P1 p1, P2 p2)
	{
		this->ft2 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
	}
	CMyTask(FuncTem3 ft,P0 p0, P1 p1, P2 p2, P3 p3)
	{
		this->ft3 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
	}
	CMyTask(FuncTem4 ft,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4)
	{
		this->ft4 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
		this->p4 = p4;
	}
	CMyTask(FuncTem5 ft,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5)
	{
		this->ft5 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
		this->p4 = p4;
		this->p5 = p5;
	}
	CMyTask(FuncTem6 ft,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6)
	{
		this->ft6 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
		this->p4 = p4;
		this->p5 = p5;
		this->p6 = p6;
	}
	CMyTask(FuncTem7 ft,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6, P7 p7)
	{
		this->ft7 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
		this->p4 = p4;
		this->p5 = p5;
		this->p6 = p6;
		this->p7 = p7;
	}
	virtual void Run()
	{
		if(!strcmp(typeid(P0).name(),"class ParamTem"))
		{
			this->ft();
		}
		else if(!strcmp(typeid(P1).name(),"class ParamTem"))
		{
			this->ft0(this->p0);
		}
		else if(!strcmp(typeid(P2).name(),"class ParamTem"))
		{
			this->ft1(this->p0,this->p1);
		}
		else if(!strcmp(typeid(P3).name(),"class ParamTem"))
		{
			this->ft2(this->p0,this->p1,this->p2);
		}
		else if(!strcmp(typeid(P4).name(),"class ParamTem"))
		{
			this->ft3(this->p0,this->p1,this->p2,this->p3);
		}
		else if(!strcmp(typeid(P5).name(),"class ParamTem"))
		{
			this->ft4(this->p0,this->p1,this->p2,this->p3,this->p4);
		}
		else if(!strcmp(typeid(P6).name(),"class ParamTem"))
		{
			this->ft5(this->p0,this->p1,this->p2,this->p3,this->p4,this->p5);
		}
		else if(!strcmp(typeid(P7).name(),"class ParamTem"))
		{
			this->ft6(this->p0,this->p1,this->p2,this->p3,this->p4,this->p5\
				,this->p6);
		}
		else if(strcmp(typeid(P7).name(),"class ParamTem"))
		{
			this->ft7(this->p0,this->p1,this->p2,this->p3,this->p4,this->p5\
				,this->p6,this->p7);
		}
	}
};
如上只定义了到含8个参数的函数模板，如果你们需要执行的函数的参数可能更多，只需要依葫芦画瓢，添加相应的函数模板即可。

另外定义这个类模板是因为在将函数加入队列貌似不太好办，我也不确定办不了，但是我是没搞出来，所以需要借助对象来保存函数。
这里说明两个地方，首先为什么要定义一个父类，而且，父类的构造函数是protected权限的，这个为了避免其他地方调用这个类生成对象，因为它是MyTask的默认模板参数，默认模板参数则是为了避免参数较少时依然要填满所以的模板参数声明。


#include "StdAfx.h"
#include "MyThreadPool.h"

CMyThreadPool::CMyThreadPool(int nThreadCount/* =5 */)
{
	this->m_nThreadCount=nThreadCount; 
	m_bthreadflag = TRUE;
	m_hsemaphore = CreateSemaphore(NULL, 0, 5000, NULL);
	InitializeCriticalSection(&m_csThreadQueue);
	InitializeCriticalSection(&m_csTaskQueue);
	m_pThreadItemList=new std::list<ThreadItem*>;
	m_pTaskList=new std::list<CTask*>;
	EnterCriticalSection(&m_csThreadQueue);
	for (int i=0;i<m_nThreadCount;i++)
	{
		ThreadItem* pItem=new ThreadItem();
		if (pItem)
		{
			pItem->pThreadPool=this;
			pItem->bThreadFlag=TRUE;
			pItem->hThreadHandle= (HANDLE)_beginthreadex(NULL, 0, ThreadFunc, (LPVOID)pItem, 0, &pItem->dwThreadID);
			printf("创建线程 threadid:%d\n",pItem->dwThreadID);
			m_pThreadItemList->push_back(pItem);
		}
	}
	LeaveCriticalSection(&m_csThreadQueue);
}

UINT WINAPI CMyThreadPool::ThreadFunc(LPVOID lpParameter /* = NULL */)
{
	//CMyThreadPool* pmyThreadPool = (CMyThreadPool*) lpParameter;
	ThreadItem *pItem = (ThreadItem*) lpParameter;
	CTask * m_pTask = NULL;
	while(pItem->bThreadFlag)
	{
		WaitForSingleObject(pItem->pThreadPool->m_hsemaphore, INFINITE);
		EnterCriticalSection(&pItem->pThreadPool->m_csTaskQueue);
		m_pTask = pItem->pThreadPool->m_pTaskList->front();
		if(m_pTask)
		{
			pItem->pThreadPool->m_pTaskList->pop_front();
		}
		LeaveCriticalSection(&pItem->pThreadPool->m_csTaskQueue);
		m_pTask->Run();
		delete m_pTask;
	}
	return NULL;
}

void CMyThreadPool::StopAllThread()
{
	EnterCriticalSection(&m_csThreadQueue);
	while (!m_pThreadItemList->empty())
	{		
		ThreadItem* pThreadItem=m_pThreadItemList->front();
		if (pThreadItem)
		{
			//TRACE("结束线程 %d\n",pThreadItem->dwThreadID);
			printf("结束线程 %d\n",pThreadItem->dwThreadID);
			pThreadItem->bThreadFlag=FALSE;
			WaitForSingleObject(pThreadItem->hThreadHandle,INFINITE);
			m_pThreadItemList->pop_front();
			delete(pThreadItem);			
		}		
	}
	LeaveCriticalSection(&m_csThreadQueue);
}


void CMyThreadPool::schedule(CTask* pTask)
{	
	EnterCriticalSection(&m_csTaskQueue);
	if (m_pTaskList)
	{
		m_pTaskList->push_back(pTask);
	}
	ReleaseSemaphore(this->m_hsemaphore,1,NULL);
	LeaveCriticalSection(&m_csTaskQueue);
}

CMyThreadPool::~CMyThreadPool()
{
	StopAllThread();
	DeleteCriticalSection(&m_csThreadQueue);
	DeleteCriticalSection(&m_csTaskQueue);
	delete m_pTaskList;
	delete m_pThreadItemList;
}
这是线程池源码，当然正如我在上面所说道的函数模板的问题，在此，其定义的另一个schedule函数需要在头文件中直接定义。 
#pragma once
#include "MyTask.h"
#include <list>
#include <process.h>
class CMyThreadPool;
struct ThreadItem
{
	HANDLE hThreadHandle;       //线程句柄
	UINT  dwThreadID;          //线程ID
	BOOL   bThreadFlag;         //线程运行标识
	CMyThreadPool* pThreadPool;   //属于哪个线程池
	ThreadItem()
	{
		hThreadHandle=NULL;
		dwThreadID=0;
		bThreadFlag=FALSE;
		pThreadPool=NULL;
	}
};

class CMyThreadPool
{
public:
	//CMyThreadPool();
	CMyThreadPool(int nThreadCount=5);
	virtual ~CMyThreadPool();
	static UINT WINAPI ThreadFunc(LPVOID lpParameter = NULL);
public:
	void schedule(CTask* pTask);
	std::list<ThreadItem*>* GetThreadItemList() {return m_pThreadItemList;};
	std::list<CTask*>*      GetTaskList() {return m_pTaskList;};
	void               StopAllThread();
	void               AdjustSize(int nThreadCount);  //动态调整线程池规模
protected:
	//static 
private:
	BOOL m_bthreadflag;   
	int m_nThreadCount;    //线程池中线程的个数
	HANDLE m_hsemaphore;
	std::list<ThreadItem*>*  m_pThreadItemList;
	std::list<CTask*>*       m_pTaskList;
	CRITICAL_SECTION    m_csThreadQueue;
	CRITICAL_SECTION    m_csTaskQueue;

	//Schedule 函数定义

public:
	template<typename ReturnType>
	void schedule(ReturnType Func())
	{
		CTask * pTask = new CMyTask<ReturnType>(Func);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
public:
	template <typename ReturnType, typename P0>
	void schedule(ReturnType Func(P0 p0),P0 p0)
	{
		CTask * pTask = new CMyTask<ReturnType,P0>(Func, p0);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1>
	void schedule(ReturnType Func(P0 p0, P1 p1),P0 p0, P1 p1)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1>(Func, p0, p1);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2),P0 p0, P1 p1, P2 p2)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2>(Func, p0, p1, p2);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3),P0 p0, P1 p1, P2 p2, P3 p3)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3>(Func, p0, p1, p2, p3);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3\
	,typename P4>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4)\
	,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3,P4>(Func, p0, p1, p2, p3, p4);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3\
		,typename P4, typename P5>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5)\
	,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3,P4,P5>(Func, p0, p1, p2, p3, p4, p5);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3\
	,typename P4, typename P5, typename P6>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6),\
	P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3,P4,P5,P6>(Func, p0, p1, p2, p3, p4, p5, p6);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3\
	,typename P4, typename P5, typename P6,typename P7>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6, P7 p7),\
	P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6, P7 p7)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3,P4,P5,P6,P7>(Func, p0, p1, p2, p3, p4, p5, p6,p7);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
};

这里我用到了一个信号量和一个临界区来保证线程安全，信号量的作用是每有一个执行的对象加入队列，就+1，反之就-1，然后利用WaitforSingleObject来让所有线程等待。临界区就不用说了，这是为了保证MyTask对象的队列的线程安全的。

最后附上线程池源码下载地址http://download.csdn.net/detail/yuguanquan1990/8109379


yuguanquan1990
关注
C++线程池案例实现讲解及参考
欧特GO
08-18 863
C++线程池案例实现讲解及参考，提供多种实现方式源码
C/C++(基于windows)超简单的线程池
09-02
1. 很适合新手学习线程池 2. 没有加锁, 大家要用的话自己加锁 3. 真的超简单, 代码量超少 4. 线程类是接口, 要自己继承才能使用, 里面有例子 5. 如果想加入 "插队" 线程机制, 可以把 STL的quene 换成 list, map等.
一个Windows C++的线程池的实现
weixin_34228617的博客
09-18 131
此线程池所依赖的线程类，请参看《一个Windows C++的线程类实现》： http://blog.csdn.net/huyiyang2010/archive/2010/08/10/5801597.aspx   ThreadPoolExecutor.h [cpp] view plaincopy #ifndef __THREAD_POOL_EXECUTOR__  #def...
C++ 线程池
最新发布
暮色尽染的博客
07-01 1582
(来自ChatGPT)线程池是一种用于管理和复用线程的机制。它可以提高程序的性能和效率，特别是在处理大量并发任务时。线程池中包含一定数量的线程，这些线程可以重复执行多个任务。当有任务需要执行时，可以将任务提交给线程池，线程池会选择一个可用的线程来执行任务。任务执行完毕后，线程会返回线程池，等待下一个任务的到来。线程池的优点：降低线程创建和销毁的开销：线程的创建和销毁是比较耗费资源的操作，使用线程池可以避免频繁地创建和销毁线程，提高程序的性能。提高系统的响应速度。
一个Windows下线程池的实现（C++）
weixin_34014277的博客
02-19 171
前言 　　本文配套代码：https://github.com/TTGuoying/ThreadPool 　　先看看几个概念： 线程：进程中负责执行的执行单元。一个进程中至少有一个线程。 多线程：一个进程中有多个线程同时运行，根据cpu切换轮流工作，在多核cpu上可以几个线程同时在不同的核心上同时运行。 线程池：基本思想还是一种对象池思想，开辟一块内存空间，里面存放一些休眠（挂起...
Windows下线程池的实现（C++）
05-16
windows下threadpool的实现 ( C++ ) 1. Task对于参数的变化参考了loki的typelist的做法，可支持0 - 9个参数的函数对象。 2. task.h使用脚本自动生成（taskGen.py） 3. scheduler.h用于解耦thread_pool和task_thread两个模块。 main.cpp演示了tp_lib的使用方法，其中TaskMgr用于统一管理任务对象，并粘合thread_pool
C++Window环境下线程池实现
weixin_54720578的博客
04-27 429
【代码】C++Window环境下线程池实现。
手写windows下c++线程池
01-12
线程池主体由两个线程构成 1、工作线程：不断的从任务队列里读取任务并且执行 2、管理线程：三秒中查询一次，根据任务和线程数量的比较来杀死线程或者生成线程 然后在需要调用线程池的地方往任务队列里添加函数就...
C++线程池结合IOCP完成端口实现socket高并发服务端程序
02-22
"C++线程池结合IOCP完成端口实现socket高并发服务端程序"是一个利用现代C++特性，结合IO Completion Ports（IOCP）技术以及线程池策略来优化socket服务器性能的项目。IOCP是Windows操作系统中一种高效的I/O模型，...
C++语言实现的线程池，结合windowsIOCP完成端口，实现socket高并发服务端程序.zip
10-19
在本项目"C++语言实现的线程池，结合windowsIOCP完成端口，实现socket高并发服务端程序.zip"中，我们关注的核心是利用C++编程语言构建一个高性能的、支持高并发的TCP服务器。线程池和Windows的IO Completion Ports...
Windows 线程池的VS2010 C++ 实现
11-01
Windows下貌似都没有一个比较好用的线程池，至少我没有找到，因此，我就利用函数模板，类模板实现了一个类似于boost的threadpool的一个类。具体，大家可以下载下来了解下，另外，这个事VS2010的工程，不过线程池的实现和vs版本无关，VS2005,2008等应该都是可以用的，VC6.0的话就不一定了，大家可以试试看看，另外，我还有一篇博客介绍了这一线程池的实现：http://blog.csdn.net/yuguanquan1990/article/details/40661583
c++ windows线程池
05-02
c++ windows线程池对于开发者来说非常重要，这是一段不错的线程池实现代码
线程池C++ windows 代码易懂
09-14
windows vs c++ 线程池 易懂，写的很清晰。还不错，分享
基于win32的C++线程池实现(改进版)
12-11
修改了上次版本的不少问题（崩溃、内存泄漏等），和我一样的初学者可以看看，整体思路挺不错的
win32线程池代码(WinApi/C++)
热门推荐
陈坚 浙江绍兴
11-06 1万+
win32线程池代码(WinApi/C++)健壮， 高效，易用，易于扩, 可用于任何C++编译器 //说明， 这段代码我用了很久， 我删除了自动调整规模的代码(因为他还不成熟)/*******************************************************************  Thread Pool For Win32 *  VC++ 6, BC++ 5.
一个Windows C++的线程池类实现
积累点滴，保持自我
10-26 1455
1.首先是线程池类： Thread.h [cpp] view plain copy #ifndef __THREAD_H__   #define __THREAD_H__      #include       #include      #include         class Runnable   {
线程池简单代码
dewk37273997的博客
11-30 204
转载别人代码；做备忘 condition.h 1 #ifndef _CONDITION_H_ 2 #define _CONDITION_H_ 3 4 #include <pthread.h> 5 6 //封装一个互斥量和条件变量作为状态 7 typedef struct condition 8 { 9 pthread_mutex_...
基于windowsapi的c++线程池
01-25
基于Windows API的C线程池是一种可以在 Windows 操作系统上实现多线程并发执行的机制。它通过有效利用系统资源来提高程序的性能和效率。 线程池是在应用程序中管理和调度线程的一种机制。传统上，每个线程的创建和...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值