基于线程池实现linux下守护进程运行web目录服务器

最新推荐文章于 2022-12-24 19:42:06 发布
最新推荐文章于 2022-12-24 19:42:06 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： Network program 文章标签： linux web path 任务 thread null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/creater2009/article/details/7427049
版权

LInux先建立线程池，主函数监听套机字，accept后，将连接套接字投入线程池处理。

自己搞的这个线程池，暂时没有发现问题，运行效果还行。

虽然free是线程安全，不可重入的。但是我们并没使用静态变量，所以不会存在问题

下为main函数，运行参数为  ./web  n  k     ;n为想线程池初始化的线程数，k为0为终端运行，k为1则转为守护进程。

运行如图



支持文件的浏览与下载


可能出现在本机上可以访问，在局域网内其他机器不能访问。则解决入下：

service iptables stop  也可以自己配置下iptables的匿名访问

如果想外网能访问，就得配置NAT

#include "unp.h"
#include "threadpoll.h"
#include "work.h"
#include "daemon.h"

int daemon_flag = 0;

int main(int argc, char **argv)
{
	int					listenfd, *connfd, num;
	socklen_t				clilen;
	struct sockaddr_in		cliaddr, servaddr;
	struct in_addr		myaddr;
	const int 				on = 1;
	if( argc != 3){
		exit(0);										/*参数错误*/
	}
	if(atoi(argv[2]) == 1) {
		daemon_ser(argv[0],LOG_USER); 			/*变成守护进程*/
		daemon_flag = 1;
	} else {
		daemon_flag = 0;
	}
	
	if((listenfd = Socket(AF_INET, SOCK_STREAM, 0)) < 0){
		//PST("socket error");
		exit(0);		
	}
	num = atoi(argv[1]);
	bzero(&servaddr, sizeof(servaddr));
	inet_pton(AF_INET, "192.168.0.108", &myaddr);		/*本服务器IP地址*/
	servaddr.sin_family      = AF_INET;
	servaddr.sin_addr.s_addr = myaddr.s_addr;
	servaddr.sin_port        = htons(80);						/*web服务为80号端口*/
	setsockopt(listenfd,SOL_SOCKET, SO_REUSEADDR, &on,	sizeof(int));
	Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
	if(inital_thread_poll(num) != 0) {							/*初始化线程池*/
		exit(0);
	}
	signal(SIGINT,clear_pool);											/*中断时，释放资源*/
	Listen(listenfd, LISTENQ);
	for ( ; ; ) {
		clilen = sizeof(struct sockaddr);
		connfd = (int * )malloc(sizeof(int));					/*每个连接一个字节*/
		if(connfd == NULL) {
			PST("Malloc connfd error");
			exit(0);
		}
		*connfd = accept(listenfd, (SA *) &cliaddr, &clilen);
		if(*connfd < 0) {
			free(connfd);
			continue;
		}
		PST("Add a connect");
		insert_task_2_poll(connfd);				/*增加任务，投入到线程池*/
	}
	clear_pool(SIGINT);									/*退出时释放资源*/
	exit(0);
}

以下为线程池，采用条件和互斥锁同步 

#include "unp.h"
#include "threadpoll.h"
#include "work.h"
#include <assert.h>

thread_pool	*pool;	
extern daemon_flag;

/*
*初始化线程池
*/
int inital_thread_poll(int num) {
	pthread_attr_t		attr;
	pthread_t		pid;
	int 				i, err;
	pool = (thread_pool *)malloc(sizeof(thread_pool));	/*在堆上分配*/
	if(pool == NULL) {
		#ifdef PRT
		PST("Malloc error");
		#endif
		return -1;
	}
	assert(pool != NULL);
	pthread_mutex_init( &(pool->mutex), NULL);		/*锁*/
	pthread_cond_init( &(pool->cond), NULL);		/*条件*/
	pool->nthreads = num;			
	pool->totaltasks = pool->runtasks = 0;		/*当前总接受的任务数和运行任务数*/
	pool->shut = 0;														/*关闭标志*/
	pool->head = pool->tail = NULL;
	pool->head = pool->tail = malloc(sizeof(task));		/*初始化头尾指针*/			
	pthread_attr_init( &attr);						/*属性*/
	pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_DETACHED);
	for( i =0; i < num; i++) {
		if((err = pthread_create( &pid, &attr, thread_func, NULL)) != 0) {	/*创建线程*/
			return err;
		}
	}
	pthread_attr_destroy( &attr);
	return 0;
}
/*
*给线程池中加入任务
*/
void insert_task_2_poll(/*void *(*func)(void *),*/ void *data) { /*添加任务*/
	task *mytask;
	mytask = (task *)malloc(sizeof(task));			/*在堆上分配*/
	if(mytask == NULL) {
		#ifdef PRT
		PST("Malloc task error");
		#endif 
		return;
	}
/*	mytask->func = func;*/
	mytask->data = data;
	pthread_mutex_lock(&(pool->mutex));
	pool->tail->next = mytask;
	mytask->prev = pool->tail;
	pool->tail = mytask;
	pool->tail->next = NULL;
	pool->totaltasks ++;						/*任务数加1*/
	pool->waittasks ++;						/*等待处理的任务数加1*/
	#ifdef PRT
		printf("Add a task ,the total tasks is %d, waittask is %d\n",pool->totaltasks,pool->waittasks);
	#endif
	pthread_cond_signal(&(pool->cond));/*唤醒等待任务的线程*/
	pthread_mutex_unlock(&(pool->mutex));
	return;
}
/*
*删除线程池中尾任务
*/
void del_task_2_poll() {				/*删除任务*/
/*	pthread_mutex_lock(&(pool->mutex));*/
	free(pool->tail->data);
	pool->tail->data = NULL;
	pool->tail = pool->tail->prev;
	free(pool->tail->next);
	pool->tail->next = NULL;
	pool->totaltasks --;
	#ifdef PRT
		printf("Delete a task ,the total tasks is %d, waittask is %d\n",pool->totaltasks,pool->waittasks);
	#endif
/*	pthread_mutex_lock(&(pool->mutex));*/
}
/*
*线程函数
*/
void *thread_func(void *arg) {  			/*等待任务，无则阻塞*/
	/*void 	*(*functemp)(void *);*/
	int		connfd;
	for( ; ;) {
		pthread_mutex_lock(&(pool->mutex));
		while(pool->waittasks == 0) 
			pthread_cond_wait(&(pool->cond), &(pool->mutex));
	/*	functemp = pool->tail->func;*/
		connfd = *((int *)(pool->tail->data));
		pool->runtasks ++;					/*处理过的任务数*/
		pool->waittasks --;					/*等待处理的任务数*/
		del_task_2_poll();						/*释放这个任务*/
		pthread_mutex_unlock(&(pool->mutex));	/*解锁，使其他线程可以等待其他任务*/
		serve_machine(&connfd);				/*任务开始执行*/
	}
}
/*
*释放线程池资源
*/
void clear_pool(int	signo) {				/*清除线程池*/
	task 	*temp;
	#ifdef PRT
	printf("\n服务器正在关闭...\n");
	#endif
	pthread_mutex_lock(&(pool->mutex));
	temp = pool->head->next;
	for(; temp != NULL; temp = pool->head->next) {
		free(pool->head->data);
		pool->head->data = NULL;
		if(pool->head->prev != NULL){
			free(pool->head->prev);
			pool->head->prev = NULL;
		}
		free(pool->head);
		pool->head = NULL;
		pool->head = temp;
	}
	/*free(temp);*/
	pthread_mutex_unlock(&(pool->mutex));
	pthread_mutex_destroy(&(pool->mutex));
	pthread_cond_destroy(&(pool->cond));
	free(pool);
	pool = NULL;
	exit(0);
}

线程池 头文件 

#ifndef _THREAD_
#define _THREAD_
#include "unp.h"
typedef struct demytask {							/*任务*/
	//void 				*(*func)(void *arg);			/*套接字处理函数指针*/
	void					*data;						/*连接套接字*/
	struct demytask		*next;						/*后向索引*/
	struct demytask		*prev;						/*后向索引*/
}task;
typedef struct pool {
	pthread_mutex_t 	mutex;				/*锁和条件*/
	pthread_cond_t	cond;
	int				nthreads;			/*线程池中线程数*/
	int				totaltasks;			/*线程池中总的任务数*/
	int				runtasks;			/*正在服务的任务数*/
	int				shut;				/*线程池关闭状态*/
	int				waittasks;			/*等待空闲线程的任务数*/
	task				*head;				/*任务头指针*/
	task				*tail;				/*任务尾指针*/
	/*pthread_t	*threads*/				/*线程ID数组，暂无用*/
}thread_pool;

void *thread_func(void *arg);			/*线程函数*/
int inital_thread_poll(int num);		/*线程池初始化*/
void insert_task_2_poll(/*void *(*func)(void *),*/ void *data);/*增加任务*/
void del_task_2_poll();				/*删除任务*/
void clear_pool(int	signo) ;			/*线程池资源释放*/
#endif


遍历目录，并响应请求，对于html语法不熟悉，参考网络 

#include "work.h"
#include <dirent.h>

char  *rootdir = "/";		/*初始页*/
char *port = "80";
char *host = "192.168.0.108";

char *dir_up(char *dirpath)
{

    static char path[MAXLINE];
    char *end;
    int len;
    strcpy(path, dirpath);
    len = strlen(path);
    if(strcmp(dirpath, "/") == 0)
			return path;
    if(len > 1) {
    	while((path[len-1] == '/')) {
    		path[len-1] = '\0';
    		len --;
    	}
    	end = (strrchr(path, '/'));
    	*end = '\0';
    }
    if(path - end == 0) {
    	path[0] = '/';
    	path[1] = '\0';
    	return path;
    }
 		return path;
}
void serve_machine(int *connfd) {
		char 	buf[MAXLINE], query[MAXLINE+1];
		int		n;
		n = recv(*connfd, buf, sizeof(buf), 0);		/*读取客户端指令*/
		sscanf(buf, "GET %s HTTP", query);
		if(n <= 0) {
			close(*connfd);
			return;
		}
		FILE *file;
		file =fdopen(*connfd, "w");
		send_2_server(file, query);
		close(*connfd);
}

void send_2_server(FILE * client_sock, char *path)
{
    struct dirent *dirent;
    struct stat info;
    char filename[MAXLINE];
    DIR *dir;
    int fd, len, ret;
    int space = 1024, nread = 0;
    char *p, *realpath, *realfilename, *nport;
    len = strlen(rootdir) + strlen(path) + 1;
    realpath = malloc(len + 1);
    bzero(realpath, len + 1);
    sprintf(realpath, "%s/%s", rootdir, path);
    len = strlen(port) + 1;
    nport = malloc(len + 1);
    bzero(nport, len + 1);
    sprintf(nport, ":%s", port);
    if (stat(realpath, &info)) {
        fprintf(client_sock,
                "HTTP/1.1 200 OK\r\nServer: DAS by renzhenwen\r\nConnection: close\r\n\r\n<html><head><title>%d - %s</title></head>"
                "<body><font size=+4>基于Linux线程池的目录访问服务器</font><br><hr width=\"100%%\"><br><center>"
                "<table border cols=3 width=\"100%%\">", errno,strerror(errno));
        fprintf(client_sock,
                "</table><font color=\"CC0000\" size=+2>不能获取当前信息：\n%s %s</font></body></html>",path, strerror(errno));
        goto out;
    }
    if (S_ISREG(info.st_mode)) {
        fd = open(realpath, O_RDONLY);
        len = lseek(fd, 0, SEEK_END);
				nread = 0;
        fprintf(client_sock,
                "HTTP/1.1 200 OK\r\nServer: DAS by renzhenwen\r\nConnection: keep-alive\r\nContent-type: application/*\r\nContent-Length:%d\r\n\r\n",len);
				p = (char *) malloc(space + 1);
        while( len > 0 ) {  		/*单缓冲读取文件*/
        	bzero(p, space + 1);
        	lseek(fd, nread, SEEK_SET);
        	ret = read(fd, p, space);
        	fwrite(p, ret, 1, client_sock);
        	len -= ret;
        	nread += ret; 
      }
      free(p);
      close(fd);
    } else if (S_ISDIR(info.st_mode)) {
        dir = opendir(realpath);
        fprintf(client_sock,
                "HTTP/1.1 200 OK\r\nServer: DAS by renzhenwen\r\nConnection: close\r\n\r\n<html><head><title>%s</title></head>"
                "<body><font size=+4>基于Linux线程池的目录访问服务器</font><br><hr width=\"100%%\"><br><center>"
                "<table border cols=3 width=\"100%%\">", path);
        fprintf(client_sock,
                "<caption><font size=+3>目录 %s</font></caption>\n",path);
        fprintf(client_sock,
                "<tr><td>名称</td><td>大小</td><td>修改时间</td></tr>\n");
        if (dir == 0) {
            fprintf(client_sock,
                    "</table><font color=\"CC0000\" size=+2>%s</font></body></html>",strerror(errno));
            return;
        }
        while ((dirent = readdir(dir)) != 0) {
            if (strcmp(path, "/") == 0)
                sprintf(filename, "/%s", dirent->d_name);
            else
                sprintf(filename, "%s/%s", path, dirent->d_name);
            fprintf(client_sock, "<tr>");
            len = strlen(rootdir) + strlen(filename) + 1;
            realfilename = malloc(len + 1);
            bzero(realfilename, len + 1);
            sprintf(realfilename, "%s/%s", rootdir, filename);
            if (stat(realfilename, &info) == 0) {
                if (strcmp(dirent->d_name, "..") == 0)
                    fprintf(client_sock,
                            "<td><a href=\"http://%s%s%s\">(parent)</a></td>",
                            host, atoi(port) == 80 ? "" : nport,
                            dir_up(path));
                else
                    fprintf(client_sock,
                            "<td><a href=\"http://%s%s%s\">%s</a></td>",
                            host, atoi(port) == 80 ? "" : nport, filename,dirent->d_name);
                if (S_ISDIR(info.st_mode))
                    fprintf(client_sock, "<td>目录</td>");
                else if (S_ISREG(info.st_mode))
                    fprintf(client_sock, "<td>%d</td>", info.st_size);
                else if (S_ISLNK(info.st_mode))
                    fprintf(client_sock, "<td>链接</td>");
                else if (S_ISCHR(info.st_mode))
                    fprintf(client_sock, "<td>字符设备</td>");
                else if (S_ISBLK(info.st_mode))
                    fprintf(client_sock, "<td>块设备</td>");
                else if (S_ISFIFO(info.st_mode))
                    fprintf(client_sock, "<td>FIFO</td>");
                else if (S_ISSOCK(info.st_mode))
                    fprintf(client_sock, "<td>Socket</td>");
                else
                    fprintf(client_sock, "<td>(未知)</td>");
                fprintf(client_sock, "<td>%s</td>", ctime(&info.st_ctime));
            }
            fprintf(client_sock, "</tr>\n");
            free(realfilename);
        }
        fprintf(client_sock, "</table></center></body></html>");
    } else {
        fprintf(client_sock,
                "HTTP/1.1 200 OK\r\nServer: DAS by renzhenwen\r\nConnection: close\r\n\r\n<html><head><title>permission denied</title></head>"
                "<body><font size=+4>基于Linux线程池的目录访问服务器</font><br><hr width=\"100%%\"><br><center>"
                "<table border cols=3 width=\"100%%\">");
        fprintf(client_sock,
                "</table><font color=\"CC0000\" size=+2>你访问的资源'%s'被禁止访问，请联系管理员解决！</font></body></html>",path);
    }
  out:
    free(realpath);
    free(nport);
}

头文件 

#ifndef  _WORK_
#define  _WORK_
#include "unp.h"

void serve_machine(int *connfd) ;		/*为客户端服务函数*/
void  send_2_server(FILE * client_sock, char *Path);
#endif

普通进程编程守护进程 

#include "daemon.h"
#include "unp.h"
/*
* 普通进程变成守护进程，APUE很详细哦
*/
int  daemon_ser(const char *name,int facility) {
	int 		i;
	pid_t		pid;
	if(( pid = fork( )) < 0) {
		return -1;
	} else if (pid > 0) {
		_exit(0);
	}
	
	if(setsid( ) < 0) {
		return -1;
	}
	signal(SIGHUP, SIG_IGN);
	if(( pid = fork( )) < 0) {
		return -1;
	} else if (pid > 0) {
		_exit(0);
	}
	chdir("/");
	for(i = 0; i < MAXFD; i++ ) {
		close(i);
	}
	open("/dev/null", O_RDONLY);
	open("/dev/null", O_RDWR);
	open("/dev/null", O_RDWR);
	openlog(name, LOG_PID, facility);
	return 0;
}

/*
* 自定义输出函数，可以递交给syslog守护进程或者终端
*/
void PST(char *ptr) {
	syslog(LOG_INFO | LOG_LOCAL7,ptr);
}

头文件 

#ifndef _DAEMON_
#define _DAEMON_
#include <syslog.h>
#include <string.h>


#define MAXFD		64
extern int daemon_flag;
int  daemon_ser(const char *name,int facility);
void PST(char *ptr);

#endif


此号已经作废
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程web服务器
12-12
计算机网络的编程作业，用c++实现一个简单的web服务器，能理解get请求即可
PYTHON多进程并发WEB服务器（利用LINUX的FORK）
weixin_33979363的博客
11-25 95
  这个又牛X 一点点。。 这还不涉及IO，如果调用GEVENT之类作异步IO或非阻塞IO，那就大框架都有啦。。 ##################################################################### # Iterative server - webserver3a.py ...
linux篇【12】：网络套接字＜后序＞—tcp接入线程池并改为守护进程
最新发布
zhang_si_hang的博客
12-24 869
父进程的id。进程本身的id。当前进程所属的进程组。（同组进程的第一个进程一般是进程组的组长）当前进程的会话id。COMMAND：命令。进程启动的时长。用户名映射后的数字，用户UID。TPGID：当前进程组和终端相关的信息，-1 说明进程和终端无关系，非-1说明有关。哪一个终端用户登录时会建立一个会话，会话内部会构建一个前台进程组 和 0个或者多个后台进程组，linux下客户端登录时 会给我们加载bash，bash就是前台进程组。
守护进程
lu_1079776757的博客
04-17 1098
守护进程首先我们先来认识一下什么是守护进程？认识守护进程    守护进程也称为精灵进程（Daemom），是运行在后台的一种特殊的进程。它独立于控制终端并且周期性的执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。Linux的大多数服务器就是用守护进程实现的。比如ftp服务器，ssh服务器，Web服务器等。同时，守护进程完成许多系统任务。比如作业规划crond。     Linux系...
Web静态服务器03-多进程
zhanghao840的博客
09-09 243
Web静态服务器-3-多进程 #coding=utf-8 import socket import re import multiprocessing class WSGIServer(object): def __init__(self, server_address): # 创建一个tcp套接字 self.listen_socket = soc...
apache tomcat7 linux tomcat7
11-21
这款服务器可以在多种操作系统上运行，包括Windows、Linux以及Unix等平台，为开发者提供了灵活且强大的Web应用程序部署环境。 在Linux系统中安装和配置Apache Tomcat7是许多系统管理员和开发者的常见任务。以下是...
linux环境weblogic集群简单配置.pdf
11-18
节点管理器是运行在物理服务器上的守护进程，它允许管理服务器远程管理和监控服务器实例，包括强制重启和健康检查。 5. 配置集群和负载均衡策略。在管理服务器上设定集群的成员，以及负载均衡的算法。 6. 部署应用...
unix下多线程(exam).rar
08-23
多线程广泛应用于网络服务器、数据库系统、图形用户界面等场景，如Web服务器通过多线程处理并发请求，数据库系统利用线程并发执行查询。 通过"threadctl"和"threads"这两个文件，我们可以深入学习和实践Unix下的多...
apache-tomcat-8.5.57-src.tar.gz
05-10
5. **Commons Daemon**：用于在非Windows操作系统上作为守护进程运行Tomcat。 6. **Connector**：Tomcat支持多种连接器，如APR（Apache Portable Runtime）连接器，利用操作系统的原生库提高性能。 解压 "apache-...
操作系统——线程
10-03
多线程广泛应用于Web服务器、数据库、图形界面、网络编程、计算密集型任务等领域，提升系统性能和用户体验。 综上所述，操作系统中的线程是并发编程的核心概念，理解和掌握其原理与实践技巧对于开发高效、可靠的多...
python多进程、守护进程、多线程、守护线程、线程池
wbl320的博客
10-14 982
多线程 multiprocessing中的Process from threading import Thread from time import time, sleep from random import randint from multiprocessing import Process def download_task(filename): print('%s开始下...
linux下mysql的安装路径、执行路径、执行守护mysqld
lgstudyvc的专栏
06-16 2145
Linux下查看mysql、apache是否安装,并卸载。   指令 ps -ef|grep mysql 得出结果 1.root     17659     1  0  2011 ?        00:00:00 /bin/sh /usr/bin/mysqld_safe --datadir=/var/lib/mysql --socket=/var/lib/mysql/mysql.sock
设置executor框架中的线程为守护线程
jl1850957991的博客
03-08 7265
http://blog.csdn.net/luman1991/article/details/77696635?locationnum=10&amp;fps=1
容器(tomcat等)关闭后，由于守护线程线程池等线程无法销毁，导致容器关闭失败
ice-wee的专栏
05-12 6678
草稿：1 如何找出某个进程下资源消耗最大的线程2 如何使用jstack根据线程查询对应的功能类3 销毁“僵尸”线程的两种方式：1 jvm关闭，关闭钩子 Runnable.addShutdownHook 2 容器销毁时关闭 3 spring的DisposableBean 4 使用钩子的注意事项...
Python中multiprocessing.Pool进程池实现守护进程的方法
NetRookieX的博客
08-20 4324
前言 在multiprocessing.Process中可以使用p.daemon=True将子进程p设置为守护进程。 那么在multiprocessing.Pool进程池中怎么实现这个功能呢？ 什么是守护进程 将子进程设置为守护进程后，若父进程退出则子进程也退出。防止产生僵尸进程。 比如下面就产生了僵尸进程。而且烦人的是，这几个僵尸进程的PID还会变，这让我怎么杀？？？ 什么是mul...
线程池
Freda的专栏
07-05 619
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永
用线程池实现的简单Web服务器
qisefengzheng的专栏 总有一天你将破蛹而出
06-17 1409
#ifndef HTTPCONNECTION_H #define HTTPCONNECTION_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include
java守护线程_Java中守护线程的总结（转）
weixin_29527111的博客
02-12 327
在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回...
守护进程简介
weixin_45629738的博客
06-14 5204
守护进程的g 守护进程也叫精灵进程，一般在后台运行，不与任何控制终端相关联。守护进程通常在 系统启动时就运行，它们以 root 用户运行或者其他特殊的用户（例如 apache）,并处理一些 系统级的任务。习惯上守护进程的名字通常以 d 结尾（如 httpd, sshd）,但这不是强制要求的。 简单讲有两个特点： ◼ 后台运行，不与终端关联 ◼ 运行周期长 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值