c++ socket线程池_Linux 下C语言简单实现线程池

最新推荐文章于 2024-06-25 02:23:19 发布
最新推荐文章于 2024-06-25 02:23:19 发布
阅读量167 收藏
点赞数
文章标签： c++ socket线程池

线程的概念就不多说，首先说一下多线程的好处：多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。

那么为什么又需要线程池呢？

我们知道应用程序创建一个对象，然后销毁对象是很耗费资源的。创建线程，销毁线程，也是如此。因此，我们就预先生成一些线程，等到我们使用的时候在进行调度，于是，一些"池化资源"技术就这样的产生了。

1 线程池优点

我所提到服务器程序是指能够接受客户请求并能处理请求的程序，而不只是指那些接受网络客户请求的网络服务器程序。

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。但如果对多线程应用不当，会增加对单个任务的处理时间。可以举一个简单的例子：

假设在一台服务器完成一项任务的时间为T

T1 创建线程的时间

T2 在线程中执行任务的时间，包括线程间同步所需时间

T3 线程销毁的时间

显然T ＝ T1＋T2＋T3。注意这是一个极度简化的假设。

可以看出T1,T3是多线程本身的带来的开销，我们渴望减少T1,T3所用的时间，从而减少T的时间。但一些线程的使用者并没有注意到这一点，所以在程序中频繁的创建或销毁线程，这导致T1和T3在T中占有相当比例。显然这是突出了线程的弱点（T1，T3），而不是优点（并发性）。

线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目。在看一个例子：

假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。我们比较利用线程池技术和不利于线程池技术的服务器处理这些请求时所产生的线程总数。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目或者上限（以下简称线程池尺寸），而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池尺寸是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

这些都是假设，不能充分说明问题，下面我将讨论线程池的简单实现并对该程序进行对比测试，以说明线程技术优点及应用领域。

需要C/C++ Linux服务器架构师学习资料加qun获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

780ac6dc6a26d3f68ce5655374a5f9d5.png

<a href="">2 线程池的简单实现

一般一个简单线程池至少包含下列组成部分。

  1. 线程池管理器（ThreadPoolManager）:用于创建并管理线程池
  2. 工作线程（WorkThread）: 线程池中线程
  3. 任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。
  4. 任务队列:用于存放没有处理的任务。提供一种缓冲机制。

下面是代码：

全局文件：

 #ifndef _GLOBAL_H_
 #define _GLOBAL_H_
 
 #include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>             /* */
#include <stdarg.h>
#include <stddef.h>             /* offsetof() */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <pwd.h>
#include <grp.h>
#include <dirent.h>
#include <glob.h>
#include <sys/vfs.h>            /* statfs() */
 
#include <sys/uio.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sched.h>
 
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>        /* TCP_NODELAY, TCP_CORK */
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/un.h>
 
#include <time.h>               /* tzset() */
#include <malloc.h>             /* memalign() */
#include <limits.h>             /* IOV_MAX */
#include <sys/ioctl.h>
#include <sys/sysctl.h>
#include <crypt.h>
#include <sys/utsname.h>        /* uname() */
#include <semaphore.h>
 
#include <sys/epoll.h>
#include <poll.h>
#include <sys/syscall.h>
#include <pthread.h>
 #endif

thread.c文件

/********************************** 
 * @author      wallwind@yeah.net
 * @date        2012/06/13
 * Last update: 2012/06/13
 * License:     LGPL
 * 
 **********************************/
 
 #ifndef _THPOOL_
 #define _THPOOL_
 
 #include "global.h"
 /**
	定义一个任务节点
 **/
 typedef void* (*FUNC)(void* arg);
 
 
 typedef struct _thpool_job_t{
//	void* (*function)(void* arg);    //函数指针
	FUNC 			 function;
 void*                   arg;     //函数参数。
 struct _thpool_job_t* prev; // 指向上一个节点
 struct _thpool_job_t* next; //指向下一个节点
 } thpool_job_t;
 
 /**
	定义一个工作队列
 **/
 
typedef struct _thpool_job_queue{
 thpool_job_t*    head;            //队列头指针 
 thpool_job_t*    tail;			   // 队列末尾指针
 int              jobN;					  //任务数
 sem_t*           queueSem;			  //x信号量
}thpool_jobqueue; 
 
 /**
	线程池
 **/
 
 typedef struct _thpool_t{
 pthread_t*      threads;    线程指针数
 int 		    threadsN;     线程数
	thpool_jobqueue* jobqueue;   // 指向队列指针
 }thpool_t;
 
 typedef struct thread_data{ 
 pthread_mutex_t *mutex_p;
 thpool_t        *tp_p;
}thread_data;
 
 //初始化线程池内部的线程数
thpool_t*  thpool_init(int threadN);
 
void thpool_thread_do(thpool_t* tp_p);
 
int thpool_add_work(thpool_t* tp_p, void *(*function_p)(void*), void* arg_p);
 
void thpool_destroy(thpool_t* tp_p);
  
int thpool_jobqueue_init(thpool_t* tp_p);
 
 
void thpool_jobqueue_add(thpool_t* tp_p, thpool_job_t* newjob_p);
 
int thpool_jobqueue_removelast(thpool_t* tp_p);
 
thpool_job_t* thpool_jobqueue_peek(thpool_t* tp_p);
 
void thpool_jobqueue_empty(thpool_t* tp_p);
 
 #endif

thread.c

/********************************** 

 * @author     wallwind@yeah.net

 * @date        2012/06/13

 * Last update: 2012/06/13

 * License:     LGPL

 * 

 **********************************/

 #include "global.h"

 #include "Thread.h"

 #include <errno.h>

 

 static int thpool_keepalive = 1;

 

 /* 创建互斥量，并初始化 */

 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /* used to serialize queue access */

 

thpool_t*  thpool_init(int threadN)

{

 thpool_t* thpool;

 if(!threadN || threadN < 1)

		threadN = 1;

 ///分配线程池内存

	thpool = (thpool_t*) malloc(sizeof(thpool_t));

 if(thpool ==NULL)

	{

 printf("malloc thpool_t error");

 return NULL;

	}

 //分配线程数

	thpool->threadsN = threadN;

	thpool->threads =(pthread_t*) malloc(threadN*sizeof(pthread_t));

 if(thpool->threads == NULL)

	{

 printf("malloc thpool->threads error");

 return NULL;

	}

 if(thpool_jobqueue_init(thpool))

 return -1;

 

	thpool->jobqueue->queueSem =(sem_t*)malloc(sizeof(sem_t));

	sem_init(thpool->jobqueue->queueSem,0,1);

 int t;

 for(t = 0;t< threadN ;t++)

	{

		pthread_create(&(thpool->threads[t]),NULL,(void *)thpool_thread_do,(void*)thpool);

	}

 

 return thpool;

}

 

void thpool_destroy(thpool_t* tp_p)

{

 int i ;

	thpool_keepalive = 0;

 

 for(i = 0;i < (tp_p->threadsN); i++)

	{

 if(sem_post(tp_p->jobqueue->queueSem))

		{

 fprintf(stderr, "thpool_destroy(): Could not bypass sem_wait()n");

		}

 

	}

 if(sem_post(tp_p->jobqueue->queueSem)!=0)

	{

 fprintf(stderr, "thpool_destroy(): Could not destroy semaphoren");

	}

 for(i = 0;i < (tp_p->threadsN); i++)

	{

		pthread_join(tp_p->threads[i],NULL);

	}

	thpool_jobqueue_empty(tp_p);

 

 free(tp_p->threads);

 free(tp_p->jobqueue->queueSem);

 free(tp_p->jobqueue);

 free (tp_p);

 

}

对双向队列初始化

/* Initialise queue */

int thpool_jobqueue_init(thpool_t* tp_p){

	tp_p->jobqueue=(thpool_jobqueue*)malloc(sizeof(thpool_jobqueue));      /* MALLOC job queue */

 if (tp_p->jobqueue==NULL) return -1;

	tp_p->jobqueue->tail=NULL;

	tp_p->jobqueue->head=NULL;

	tp_p->jobqueue->jobN=0;

 return 0;

}

 

 

void thpool_thread_do(thpool_t* tp_p)

{

 while(thpool_keepalive ==1)

	{

 if(sem_wait(tp_p->jobqueue->queueSem)) ///线程阻塞,等待通知 直到消息队列有数据

		{

			perror("thpool_thread_do(): Waiting for semaphore");

 exit(1);

		}

 if(thpool_keepalive)

		{

 //(void*)(*function)(void *arg);

			FUNC function;

 void* arg_buff;

 thpool_job_t*  job_p;

 

			pthread_mutex_lock(&mutex);

			 job_p = thpool_jobqueue_peek(tp_p);

			function = job_p->function;

			arg_buff = job_p->arg;

 if(thpool_jobqueue_removelast(tp_p))

 return ;

			pthread_mutex_unlock(&mutex);

			function(arg_buff);   //运行 你的方法。

 free(job_p);         释放掉。

		}

 else

		{

 return ;

		}

 

	}

 return ;

}

 

//得到第一个队列的一个节点

thpool_job_t* thpool_jobqueue_peek(thpool_t* tp_p)

{

 return tp_p->jobqueue->tail;

}

/删除队列的最后一个节点

int thpool_jobqueue_removelast(thpool_t* tp_p)

{

 if(tp_p ==NULL)

 return -1;

 thpool_job_t* theLastJob;

	theLastJob = tp_p->jobqueue->tail;

 switch(tp_p->jobqueue->jobN)

	{

 case 0:

 return -1;

 case 1:

			tp_p->jobqueue->head =NULL;

			tp_p->jobqueue->tail =NULL;

 break;

 default:

			theLastJob->prev->next = NULL;

			tp_p->jobqueue->tail = theLastJob->prev;

 

	}

	(tp_p->jobqueue->jobN)--;

 int reval;

	sem_getvalue(tp_p->jobqueue->queueSem,&reval);

 return 0;	

}

 

void thpool_jobqueue_add(thpool_t* tp_p, thpool_job_t* newjob_p)

{

	newjob_p->next = NULL;

	newjob_p->prev = NULL;

 thpool_job_t* oldFirstJob;

	oldFirstJob = tp_p->jobqueue->head;

 

 switch(tp_p->jobqueue->jobN)

	{

 case 0:

			tp_p->jobqueue->head = newjob_p;

			tp_p->jobqueue->tail = newjob_p;

 break;

 default:

			oldFirstJob->prev = newjob_p;

			newjob_p->next = oldFirstJob;

			tp_p->jobqueue->head = newjob_p;

 

	}

	(tp_p->jobqueue->jobN)++;

	sem_post(tp_p->jobqueue->queueSem);

 

 int reval;

	sem_getvalue(tp_p->jobqueue->queueSem,&reval);

 return;

}

 

/将消息加入线程池

int thpool_add_work(thpool_t* tp_p, void* (*function_p)(void*), void* arg_p)

{

 thpool_job_t* newjob;

	newjob = (thpool_job_t*) malloc(sizeof(thpool_job_t));

 

 if(newjob ==NULL)

	{

 fprintf(stderr, "thpool_add_work(): Could not allocate memory for new jobn");

 exit(1);

	}

	newjob ->function = function_p;

	newjob ->arg      = arg_p;

	pthread_mutex_lock(&mutex);

	thpool_jobqueue_add(tp_p,newjob);

	pthread_mutex_unlock(&mutex);     

 return 0;

}

 

///清空队列

void thpool_jobqueue_empty(thpool_t* tp_p)

{

 thpool_job_t* curjob;

	curjob = tp_p->jobqueue->tail;

 

 while(tp_p->jobqueue->jobN)

	{

		tp_p->jobqueue->tail = curjob->prev;

 free (curjob);

		curjob = tp_p->jobqueue->tail;

		(tp_p->jobqueue->jobN)--;

	}

	tp_p->jobqueue->head = NULL;
	tp_p->jobqueue->tail = NULL;
}

下面是mian函数文件

/********************************** 
 * @author      wallwind@yeah.net
 * @date        2012/06/13
 * Last update: 2012/06/13
 * License:     LGPL
 * 
 **********************************/
 
#include "global.h"
#include "Thread.h"
 
 void* task1()
	{
 printf("# Thread working: %un", (int)pthread_self());
 printf("  Task 1 running..n");
	}
 
 
 /* Some arbitrary task 2 */
 void* task2(int a)
	{
 printf("# Thread working: %un", (int)pthread_self());
 printf("  Task 2 running..n");
 printf("%dn", a);
	}
int main()
{
 printf("~~~~~~~~~~~");
 thpool_t* thpool;
 int i;
	thpool = thpool_init(5);
 puts("Adding 20 tasks to threadpool");
 int a=54;
 for (i=0; i<20; i++){
		thpool_add_work(thpool, (void*)task1, NULL);
		thpool_add_work(thpool, (void*)task2, (void*)a);
	};
 
 
 puts("Will kill threadpool");
	thpool_destroy(thpool);
 
}


在linux下写程序少不了makefile文件。于是我自己写了一个比较通用的makefile文件。仅供大家参考

makefile 代码

SRCS=$(wildcard *.c)
OBJS=$(SRCS:.c=.o)
CC=gcc
INCLUDES=-I/
LIBS=-L/ -lpthread
CCFLAGS = -g -Wall -O0
cThreadPool : $(OBJS)
        $(CC) $^ -o $@ $(INCLUDES) $(LIBS)
%.o : %.cpp
        $(CC) -c $<$(CCFLAGS)
clean:
        rm *.o
        .PHONY:clean

运行效果如下

./test
Created thread 0 in pool 
Created thread 1 in pool 
Created thread 2 in pool 
Created thread 3 in pool 
Adding 20 tasks to threadpool
# Thread working: 3086773136
  Task 1 running..
# Thread working: 3076283280
  Task 2 running..
54
# Thread working: 3086773136
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
# Thread working: 3076283280
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
# Thread working: 3076283280
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
# Thread working: 3076283280
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
# Thread working: 3076283280
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
# Thread working: 3076283280
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
# Thread working: 3076283280
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
# Thread working: 3076283280
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
# Thread working: 3076283280
  Task 1 running..
# Thread working: 3086773136
  Task 2 running..
54
Will kill threadpool
weixin_39752800
关注
C++线程池结合IOCP完成端口实现socket高并发服务端程序
02-22
C++线程池结合IOCP完成端口实现socket高并发服务端程序 包含mysql数据库操作、json数据解析
嵌入式面试题整理 -（linux、c语言、c++、单片机）
08-08
#### Linux下的Socket套接字与Windows下的WinSock共同点 1. **基于TCP/IP协议**：无论是Linux下的Socket还是Windows下的WinSock，两者都基于TCP/IP协议栈。这意味着它们都能提供面向连接的TCP服务和无连接的UDP服务...
Linux 下C语言简单实现线程池
wintree的专栏
06-16 1万+
C语言简单实现线程池 0 前言 网上关于线程池的例子还是不少，简单明了的倒是比较少，看了网上的资料，打算借鉴网上的一些例子，自己实现以下。 线程的概念就不多说，首先说一下多线程的好处：多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。 那么为什么又需要线程池呢？ 我们知道应用程序创建一个对象，然后销毁对象是很耗费资源的
Linux C++线程池的设计与实现
最新发布
weixin_54423699的博客
06-25 1575
简单的来说就是二级指针进行解引用，可以控制从起始地址到起始地址+8个字节的空间，为什么时8个字节因为二级指针解引用后是一级指针，一级指针只占用8个字节的内存。很多例子使用std里面的vector和queue来管理线程和任务队列，虽然方便好用但是不是很能够深入，而且c++语言特性过多不利于理解线程池的核心思想，因此本文只使用C语言实现。任务管理模块主要负责接收外部提交的任务，将其加入到任务队列中，并确保这些任务能被线程池中的线程正确执行。线程管理模块主要负责线程的创建、销毁、以及线程的同步与通信。
ThreadPool - 线程池学习
qq_40674490的博客
03-22 177
1. 线程池的概念： 线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。 2. 线程池的工作机制 2.1 在线程池的编程模式下，任务是提...
一个Linux下C线程池的实现(转)
热门推荐
hubi0952的专栏
10-07 4万+
1.线程池基本原理   在传统服务器结构中, 常是 有一个总的 监听线程监听有没有新的用户连接服务器, 每当有一个新的 用户进入, 服务器就开启一个新的线程用户处理这 个用户的数据包。这个线程只服务于这个用户 , 当 用户与服务器端关闭连接以后, 服务器端销毁这个线程。然而频繁地开辟与销毁线程极大地占用了系统的资源。而且在大量用户的情况下, 系统为了开辟和销毁线程将浪费大量的时间和资源。线程池提
Linux下使用EPoll+队列+多线程的C++实现
12-24
在这个“Linux下使用EPoll+队列+多线程的C++实现”项目中，开发者使用了`epoll`来监听并管理TCP服务器的连接。`epoll`的工作流程大致如下： 1. **创建epoll句柄**：首先，通过`epoll_create()`函数创建一个epoll...
linux， c++， 线程池 ， socket
04-01
在Linux系统中，使用C语言编写的程序通常会使用线程池和Socket来实现高效的并发通信。例如，可以使用线程池来管理多个网络连接，以及使用Socket来实现客户端和服务器之间的通信。同时，Linux系统提供了丰富的系统...
linux c++ socket 多线程1
08-26
本文将深入探讨Linux环境下的C++ Socket网络编程和多线程技术，基于提供的资料列表进行详细解析。 首先，"C++_Socket网络编程大全"是关于使用C++进行Socket编程的全面教程。Socket是网络通信的基础，它为应用程序...
单线程实现同时监听多个端口（windows平台c++代码）
09-27
在Windows平台上，使用C++开发网络应用程序时，我们经常需要处理多端口监听的问题。...此外，由于这是一个特定于Windows的解决方案，跨平台的网络编程可能需要使用其他技术，如Linux下的epoll或BSD的kqueue。
socket 线程池实现
12-22
一个很好的socket 线程池实现示例，希望对想了解线程池的朋友有所帮助
Java多线程之并发包，并发队列
losemyfuture的博客
07-25 995
目录 1 并发包 1.1同步容器类 1.1.1Vector与ArrayList区别 1.1.2HasTable与HasMap 1.1.3 synchronizedMap 1.1.4 ConcurrentHashMap 1.1.5 CountDownLatch​​​​​​ 1.1.6 CyclicBarrier 1.1.6 Semaphore 2 并发队列 2.1 Concur...
c++ socket线程池_linux进程间通信---本地socket套接字(六)---线程池原理及C语言实现线程池...
weixin_39611037的博客
11-26 187
本人的微信公众号正式上线了，搜索:张笑生的地盘，主要关注嵌入式软件开发，股票基金定投，足球等等，希望大家多多关注，有问题可以直接留言给我，一定尽心尽力回答大家的问题一 why先谈谈为什么会有这篇博客，如果只是为了介绍线程池，我相信大家都有相关概念，或者去各大技术博客上也能搜到相关知识。那在这里我为什么还要谈谈线程池的知识呢？在前面的博客《linux进程间通信—本地socket套接字(三)—多线程实...
线程池的基本原理，看完就懂了
07-08 92
原文地址：http://blog.jboost.cn/threadpool.html 本文内容是基于研发部门内部的分享整理，记录下来供学习或回顾。 1. 为什么要用线程池 降低资源消耗。通过重复利用已创建的线程降低线程创建、销毁线程造成的消耗。 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资...
c语言socket之线程池模型开发服务器与客户端。
jenie的专栏
06-23 450
事先先创建好线程，等待链接再分配 ，省去创建的时间。 #include <stdio.h> #include <stdlib.h> #include <sys/socket.h> #include <netinet/in.h> #include <string.h> #include <pthread.h> #include <unistd.h> const int Port = 8008; pthread_mute.
C-socket编-线程池
wwzhang0307的博客
04-17 1258
#include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <assert.h> #include <stdio.h> #include <string.h> #include <signal.h> #include <errno.h> /*#include "threadpool.h"*/ #define DEFAUL
c++ socket线程池原理_深入线程池的实现原理：如何配置一个合适的线程池
weixin_39717865的博客
11-29 137
前言本文会出现一些阻塞队列相关的只是，这种队列除了有队列Queue的特性之外，还有阻塞的特性，例如take方法会获取元素时若队列为空会阻塞直到有元素被添加等等，还有很多特性，可以看这篇文章，带你了解阻塞队列本篇文章的议题如下：线程池的运行原理的源码分析如何配置一个合适的线程池？为什么要使用线程池首先，为什么我们需要线程池呢？直接 new Thread().start() 不行吗？在 Thread#...
c++ socket线程池原理_线程池原理详解及如何用C语言实现线程池
weixin_39714015的博客
11-27 314
线程池是一种多线程处理形式，大多用于高并发服务器上，它能合理有效的利用高并发服务器上的线程资源；线程与进程用于处理各项分支子功能，我们通常的操作是：接收消息 ==> 消息分类 ==> 线程创建 ==> 传递消息到子线程 ==> 线程分离 ==> 在子线程中执行任务 ==> 任务结束退出； 对大多数小型局域网的通信来说，上述方法足够满足需求；但当我们的通信范围扩大...
Linux C语言实现线程池详解
在C语言中实现线程池需要注意线程同步和通信问题。可以使用互斥锁（mutex）、条件变量（condition variable）等工具确保线程安全地访问共享数据结构。例如，添加任务到工作队列、启动新线程以及检查线程池是否应关闭...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值