基于线程池的目录拷贝项目

最新推荐文章于 2024-10-06 21:26:23 发布
最新推荐文章于 2024-10-06 21:26:23 发布
阅读量63 收藏
点赞数
文章标签： 服务器 linux c语言 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49608749/article/details/132978782
版权

项目要求

1）实现文件与文件的拷贝
2）实现目录与目录的拷贝
3）文件与文件的复制 目标文件是否可以绝对/相对路径复制
4）目录与目录的复制 目标目录是否可以绝对/相对路径复制
5）能根据实际情况实现特定要求下的拷贝操作

main.c

#include "thread_pool.h"

int main(int argc,char *argv[])
{
	//初始化线程池,创建3条线程
	thread_pool* pool = malloc(sizeof(thread_pool));
	init_pool(pool, 3);
	
	if(argc != 3)
	{
		printf("输入参数数目错误，请重新输入...\n");
		return -1;
	}
	
	//创建结构体，获取源文件和目录文件
	file_name fileName;
	strcpy(fileName.src,argv[1]);
	strcpy(fileName.dst,argv[2]);
	
	//定义源文件的文件结构体指针指向源文件，并开辟堆区空间，用于存放内容
	struct stat* source_file = malloc(sizeof(struct stat));
	stat(fileName.src,source_file);
	
	//定义目的文件的文件结构体指针指向目的文件，并开辟堆区空间，用于存放内容
	struct stat* target_file = malloc(sizeof(struct stat));
	stat(fileName.dst,target_file);
	
	//对拷贝类型进行判断，从而使用不同的拷贝函数(文件到文件，目录到目录，文件到目录)
	file_file(source_file,target_file,pool,(char *)&fileName.src,(char *)&fileName.dst);
	dir_dir(source_file,target_file,pool,(char *)&fileName.src,(char *)&fileName.dst);
	file_to_dir(source_file,target_file,pool,(char *)&fileName.src,(char *)&fileName.dst);

	//销毁线程池
	destroy_pool(pool);
	
	return 0;
}

thread_pool.c

#include "thread_pool.h"

void handler(void *arg)
{
	printf("[%u] is ended.\n",
		(unsigned)pthread_self());

	pthread_mutex_unlock((pthread_mutex_t *)arg);
}

// 子线程工作的任务
void *routine(void *arg)
{
	#ifdef DEBUG
	printf("[%u] is started.\n",
		(unsigned)pthread_self());
	#endif

	thread_pool *pool = (thread_pool *)arg;
	struct task *p;

	while(1)
	{
		/*
		** push a cleanup functon handler(), make sure that
		** the calling thread will release the mutex properly
		** even if it is cancelled during holding the mutex.
		**
		** NOTE:
		** pthread_cleanup_push() is a macro which includes a
		** loop in it, so if the specified field of codes that 
		** paired within pthread_cleanup_push() and pthread_
		** cleanup_pop() use 'break' may NOT break out of the
		** truely loop but break out of these two macros.
		** see line 61 below.
		*/
		// 保存锁资源，防止线程被取消导致死锁
		// 如果线程被取消会调用handler函数
		//================================================//
		pthread_cleanup_push(handler, (void *)&pool->lock);
		pthread_mutex_lock(&pool->lock);
		//================================================//

		// 1, no task, and is NOT shutting down, then wait
		// 没有任务并且线程池正常工作，那么线程休眠
		while(pool->waiting_tasks == 0 && !pool->shutdown)
		{
			pthread_cond_wait(&pool->cond, &pool->lock);
		}

		// 2, no task, and is shutting down, then exit
		// 没有任务，并且线程池要结束，解锁，所有线程退出
		if(pool->waiting_tasks == 0 && pool->shutdown == true)
		{
			pthread_mutex_unlock(&pool->lock);
			pthread_exit(NULL); // CANNOT use 'break';
		}

		// 3, have some task, then consume it
		// 有任务，线程取任务并执行
		p = pool->task_list->next;
		pool->task_list->next = p->next;
		// 任务减1
		pool->waiting_tasks--;

		//================================================//
		pthread_mutex_unlock(&pool->lock);
		pthread_cleanup_pop(0);
		//================================================//
		// 线程工作的时候，不能被取消
		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
		// 调用回调函数，进行任务处理
		(p->do_task)(p->arg);
		// 线程恢复取消
		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

		free(p);
	}

	pthread_exit(NULL);
}

// 初始化线程池
bool init_pool(thread_pool *pool, unsigned int threads_number)
{
	// 初始化锁与条件量
	pthread_mutex_init(&pool->lock, NULL);
	pthread_cond_init(&pool->cond, NULL);
	
	// false表示线程正常工作，true表示销毁线程池
	pool->shutdown = false;
	// 给任务链表分配空间
	pool->task_list = malloc(sizeof(struct task));
	// 给线程分配空间，最多是20条线程
	pool->tids = malloc(sizeof(pthread_t) * MAX_ACTIVE_THREADS);

	if(pool->task_list == NULL || pool->tids == NULL)
	{
		perror("allocate memory error");
		return false;
	}
	
	// 刚开始没有任务
	pool->task_list->next = NULL;
	// 最大等待任务1000个节点
	pool->max_waiting_tasks = MAX_WAITING_TASKS;
	// 等待任务没有
	pool->waiting_tasks = 0;
	// 在职的线程
	pool->active_threads = threads_number;

	int i;
	for(i=0; i<pool->active_threads; i++)
	{
		if(pthread_create(&((pool->tids)[i]), NULL,
					routine, (void *)pool) != 0)
		{
			perror("create threads error");
			return false;
		}

		#ifdef DEBUG
		printf("[%u]:[%s] ==> tids[%d]: [%u] is created.\n",
			(unsigned)pthread_self(), __FUNCTION__,
			i, (unsigned)pool->tids[i]);
		#endif
	}

	return true;
}

// 添加任务
bool add_task(thread_pool *pool,
	      void *(*do_task)(void *arg), void *arg)
{
	struct task *new_task = malloc(sizeof(struct task));
	if(new_task == NULL)
	{
		perror("allocate memory error");
		return false;
	}
	new_task->do_task = do_task;//mytask
	new_task->arg = arg;
	new_task->next = NULL;

	//============ LOCK =============//
	pthread_mutex_lock(&pool->lock);
	//===============================//

	if(pool->waiting_tasks >= MAX_WAITING_TASKS)
	{
		pthread_mutex_unlock(&pool->lock);

		fprintf(stderr, "too many tasks.\n");
		free(new_task);

		return false;
	}
	
	struct task *tmp = pool->task_list;
	// 将新任务插到链表尾
	while(tmp->next != NULL)
		tmp = tmp->next;

	tmp->next = new_task;
	pool->waiting_tasks++;

	//=========== UNLOCK ============//
	pthread_mutex_unlock(&pool->lock);
	//===============================//

	#ifdef DEBUG
	printf("[%u][%s] ==> a new task has been added.\n",
		(unsigned)pthread_self(), __FUNCTION__);
	#endif
	// 链表有任务，广播通知睡觉的线程起来工作
	pthread_cond_signal(&pool->cond);
	return true;
}

// 添加新线程
int add_thread(thread_pool *pool, unsigned additional_threads)
{
	if(additional_threads == 0)
		return 0;

	unsigned total_threads =
			pool->active_threads + additional_threads;

	int i, actual_increment = 0;
	for(i = pool->active_threads;
	    i < total_threads && i < MAX_ACTIVE_THREADS;
	    i++)
	{
		if(pthread_create(&((pool->tids)[i]),NULL, routine, (void *)pool) != 0)
		{
			perror("add threads error");

			// no threads has been created, return fail
			if(actual_increment == 0)
				return -1;

			break;
		}
		actual_increment++; 

		#ifdef DEBUG
		printf("[%u]:[%s] ==> tids[%d]: [%u] is created.\n",
			(unsigned)pthread_self(), __FUNCTION__,
			i, (unsigned)pool->tids[i]);
		#endif
	}

	pool->active_threads += actual_increment;
	return actual_increment;
}

// 删除线程
int remove_thread(thread_pool *pool, unsigned int removing_threads)
{
	if(removing_threads == 0)
		return pool->active_threads;

	int remaining_threads = pool->active_threads - removing_threads;
	// 最低要保留一条线程，不能团灭
	remaining_threads = remaining_threads > 0 ? remaining_threads : 1;

	int i;
	for(i=pool->active_threads-1; i>remaining_threads-1; i--)
	{
		// 取消不工作的线程
		errno = pthread_cancel(pool->tids[i]);

		if(errno != 0)
			break;

		#ifdef DEBUG
		printf("[%u]:[%s] ==> cancelling tids[%d]: [%u]...\n",
			(unsigned)pthread_self(), __FUNCTION__,
			i, (unsigned)pool->tids[i]);
		#endif
	}

	if(i == pool->active_threads-1)
		return -1;
	else
	{
		pool->active_threads = i+1;
		return i+1;
	}
}

// 销毁线程
bool destroy_pool(thread_pool *pool)
{
	// 1, activate all threads
	pool->shutdown = true;
	// 唤醒正在睡觉的线程
	pthread_cond_broadcast(&pool->cond);

	// 2, wait for their exiting
	int i;
	for(i=0; i<pool->active_threads; i++)
	{
		// 等待线程退出
		errno = pthread_join(pool->tids[i], NULL);
		if(errno != 0)
		{
			printf("join tids[%d] error: %s\n",
					i, strerror(errno));
		}
		else
			printf("[%u] is joined\n", (unsigned)pool->tids[i]);
		
	}

	// 3, free memories
	// 释放资源
	free(pool->task_list);
	free(pool->tids);
	free(pool);

	return true;
}

void copyfile(int src,int dst)
{
	char buf[100] = { 0 };	
	int ret = 0;
	
	while(1)
	{
		ret = read(src,buf,100);
		
		if(ret == 0)
		{
			break;
		}
		
		write(dst,buf,ret);
	}
	
	close(src);
	close(dst);
}

void* task(void* arg)
{
	//调用复制文件的函数
	int* fd = (int *)arg;
	
	copyfile(fd[0],fd[1]);
	
	usleep(100);
}

void file_file(struct stat* source_file,struct stat* target_file,thread_pool* pool,char* src_file,char *dst_file)
{
	//源文件是文件，目标文件不是目录
	if(S_ISREG(source_file->st_mode) && !S_ISDIR(target_file->st_mode))
	{
		printf("源文件是普通文件，目标文件不是目录\n");
		printf("开始拷贝文件：%s ----> %s\n",src_file,dst_file);
		
		int* fd = calloc(2,sizeof(int));
		
		//打开源文件
		fd[0] = open(src_file,O_RDWR);
		fd[1] = open(dst_file,O_RDWR);
		
		//添加任务
		add_task(pool,task,(void *)fd);
	
	}
}


bool copydir(thread_pool* pool,char* src,char* dst,struct stat* info)
{	
	//定义一个stat结构体指针，开辟堆区空间
	struct stat* fileinfo = malloc(sizeof(struct stat));
	stat(dst,fileinfo);
	
	if(!S_ISDIR(fileinfo->st_mode))
	{
		printf("%s不是目录文件!\n",dst);
		return false;
	}
 
	char current_path[100] = {0};//当前路径
	char from_path[100] = {0};//源目录路径
	char dst_path[100] = {0};//目标目录路径
	
	//获取当前的路径
	getcwd(current_path,100);
	
	//获取源文件的路径存在buf里面	
	chdir(src);           
	getcwd(from_path,100);
	
	chdir(current_path); 	
	chdir(dst);               
	getcwd(dst_path,100);
	
	//打开目录
	DIR* dp = opendir(from_path);
	
	//切换到目录里面去
	chdir(from_path);
	
	//通过读目录将文件名读出来
	while(1)
	{
		struct dirent* ep = readdir(dp);
		if(ep == NULL)
		{
			break;
		}
		
		//条件判断(如果读取的文件是'.'和'..'不打印)
		if(ep->d_name[0] == '.')
			continue;
 
		printf("ep->d_name(文件名字):%s\n",ep->d_name);
		
		bzero(fileinfo,sizeof(struct stat));
		
		chdir(from_path);
		
		stat(ep->d_name,fileinfo);
		
		//目录里面是文件
		//使用文件拷贝方法
		if(S_ISREG(fileinfo->st_mode))
		{
			int* fd = calloc(2, sizeof(int));
				
			fd[0] = open(ep->d_name, O_RDONLY);
	
			chdir(dst_path);  
			fd[1] = open(ep->d_name, O_WRONLY|O_CREAT,fileinfo->st_mode);
					
			usleep(100);
			
			add_task(pool,task,(void*)fd); 	
			
		}
		
		// 目录里面是目录
		// 使用目录拷贝方法
		if(S_ISDIR(fileinfo->st_mode))
		{
			chdir(dst_path);    
			// mkdir(ep->d_name,fileinfo->st_mode);
			chdir(ep->d_name);
			
			char new_path[100];
			getcwd(new_path,100);
			
			chdir(from_path);
			copydir(pool,ep->d_name,new_path,fileinfo);
 
		}
	}	
}
	
void dir_dir(struct stat* source_file,struct stat* target_file,thread_pool* pool,char* src_file,char *dst_file)
{
	//判断是否是目录文件
	if(S_ISDIR(source_file->st_mode))
	{
		printf("源文件是目录,目标文件是目录\n");
		printf("开始拷贝目录：%s ----> %s\n",src_file,dst_file);
				
		//拷贝目录文件
		copydir(pool,src_file,dst_file,source_file);
		
	}
}

void file_to_dir(struct stat* source_file,struct stat* target_file,thread_pool* pool,char* src_file,char* dst_file)
{
	if(S_ISREG(source_file->st_mode) && S_ISDIR(target_file->st_mode))
	{
		//定义一个stat结构体指针，开辟堆区空间
		struct stat* fileinfo = malloc(sizeof(struct stat));
		stat(dst_file,fileinfo);

		char dst_path[100] = {0};//目标目录路径
		char current_path[100] = {0};//当前路径

		//获取当前的路径
		getcwd(current_path,100);
			
		chdir(dst_file);               
		getcwd(dst_path,100);
		chdir(current_path); 

		int* fd = calloc(2, sizeof(int));

		fd[0] = open(src_file,O_RDWR|O_CREAT,source_file->st_mode);
		if(fd[0] == -1)
		{
			printf("open fail\n");
		}
		
		//打开目录
		DIR* dp = opendir(dst_file);
		
		//切换到目录里面去
		chdir(dst_path);

		while (1)
		{
			struct dirent* ep = readdir(dp);
			if(ep == NULL)
			{
				break;
			}
				
			//条件判断(如果读取的文件是'.'和'..'不打印)
			if(ep->d_name[0] == '.')
				continue;
		
			printf("ep->d_name(文件名字):%s\n",ep->d_name);	
			
			//源文件是文件，目标文件是目录
			if(S_ISREG(source_file->st_mode) && S_ISDIR(target_file->st_mode))
			{
				printf("源文件是普通文件,目标文件是目录\n");
				
				
				fd[1] = open(src_file,O_WRONLY|O_CREAT,target_file->st_mode);
				if(fd[1] == -1)
				{
					printf("open fail\n");
				}

				//添加任务
				add_task(pool,task,(void *)fd);
			}
		}
	}

}

thread_pool.h

#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

#include <stdio.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

#include <errno.h>
#include <pthread.h>

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

#include<dirent.h>

#define MAX_WAITING_TASKS	1000
#define MAX_ACTIVE_THREADS	20

typedef struct file_name
{
	char src[100];
	char dst[100];
}file_name;

// 任务
struct task
{
	void *(*do_task)(void *arg);// 回调函数，处理任务
	void *arg;// 任务数据

	struct task *next;//链表指针，指向下一个节点
};

typedef struct thread_pool
{
	pthread_mutex_t lock;// 锁
	pthread_cond_t  cond;// 条件量，通知线程工作

	bool shutdown;//线程销毁

	struct task *task_list;//任务链指针

	pthread_t *tids;//线程ID

	unsigned max_waiting_tasks;// 等待最大线程数
	unsigned waiting_tasks;// 任务队列中等待的任务个数
	unsigned active_threads;// 当前活跃的线程数
}thread_pool;

// 初始化线程
bool init_pool(thread_pool *pool, unsigned int threads_number);
// 添加任务
bool add_task(thread_pool *pool, void *(*do_task)(void *arg), void *task);
// 添加线程
int  add_thread(thread_pool *pool, unsigned int additional_threads_number);
// 删除线程
int  remove_thread(thread_pool *pool, unsigned int removing_threads_number);
// 销毁线程
bool destroy_pool(thread_pool *pool);
// 工作线程
void *routine(void *arg);
void file_to_dir(struct stat* source_file,struct stat* target_file,thread_pool* pool,char* src_file,char* dst_file);
void dir_dir(struct stat* source_file,struct stat* target_file,thread_pool* pool,char* src_file,char *dst_file);
bool copydir(thread_pool* pool,char* src,char* dst,struct stat* info);
void file_file(struct stat* source_file,struct stat* target_file,thread_pool* pool,char* src_file,char *dst_file);
void* task(void* arg);
void copyfile(int src,int dst);


#endif

Makefile

CC = gcc
CFLAGS = -O -lpthread

test:main.c thread_pool.c
	$(CC) $^ -o $@ $(CFLAGS)

debug:main.c thread_pool.c
	$(CC) $^ -o $@ $(CFLAGS) -DDEBUG

clean:
	$(RM) .*.sw? test debug *.o

.PHONY:all clean
盛真皮
关注
利用线程池书写文件夹复制（C语言）
荆州张球王的博客
10-19 1272
如题 #include <stdio.h> #include <pthread.h> #include <stdlib.h> #include <stdbool.h> #include<unistd.h> #include<string.h> #include<strings.h> #include<errn...
基于lnux的线程池实现目录拷贝
只见天空的博客
07-08 3230
1.线程池：一个包括互斥锁、条件变量、任务链表、线程id集合、等待任务数目、线程数目、以及开关的结构体，实现多个线程处理任务。包括
线程池实现目录拷贝
我真的好难的博客
08-25 1867
线性池实现目录拷贝
项目：使用线程池实现大目录拷贝
ZL_BKPD的博客
10-12 3344
项目：使用线程池实现大目录拷贝 创建一个线程的综合资源，让需要执行的任务挂载在线程池中。如果线程池有空闲的线程，就可以安排线程去执行任务，如果线程池没有空闲的线程，就安排任务等待，直到有线程空闲出来。 线程池步骤： 初始化线程池资源 向线程池中加入线程 向线程池中添加任务 ---如果有空闲的线程，空闲线程可以自动获取任务并运行 销毁线程池。 源码分享：thread_pool.c /* 设计思路： 1、预处理板块：构建任务结...
基于线程池的HTTP服务器(C/C++)
我只是一个路过的老年人
06-16 1533
浏览器输入用户名密码登录注册到注册成功，返回注册成功页面底层发生了什么？想大概了解http/1.0协议底层大概如何实现的吗？这个小项目将带你了解。
【线程池项目（一）】项目介绍和代码展示
icc_hhy的博客
02-21 1220
作为五大池之一（内存池、连接池、线程池、进程池、协程池），线程池的应用非常广泛，不管是客户端程序，还是后台服务器程序，都是提高业务处理能力的必备模块。在高并发场景下，系统能够更加稳定地处理大量任务。
线程池小项目【Linux & C/C++】(踩坑分享)
菜菜成长为后端开发大佬
04-03 1283
目录前提知识：一，线程池意义二，实现流程阶段一，搭建基本框架1. 利用linux第三方库，将pthread_creat线程接口封装2. 实现基本主类ThreadPool基本结构 阶段二，完善多线程安全1. 日志信息打印——模拟企业级日常日志记录2. C/C++的格式化输出3. C，C++接口套用时，考虑this指针阶段三，优化为单例模式——懒汉四，源码C/C++线程接口使用，可参考多线程基础入门【Linux之旅】——上篇【线程控制 || 线程互斥 || 线程安全】-CSDN博客互斥锁，信号量知识，可参考多线
Linux线程池目录拷贝
01-10
并发控制是线程池拷贝目录时的另一个关键点。由于多个线程可能同时尝试访问或修改同一个文件，因此需要使用互斥锁（`pthread_mutex_t`）或者信号量（`pthread_semaphore_t`）来确保线程安全。此外，条件变量（`...
demo.rar线程池、文件io拷贝
05-07
该项目使用了线程池进行多线程文件快速的拷贝，可同时复制不同的文件，在不同情况下和不同文件类型的文件以及多重嵌套的文件，该程序都能完美的进行拷贝。用户在使用时，需要输入两个参数，第一个是必须存在的复制...
基于liunx操作系统的线程池项目
09-03
项目中实现目录名的拷贝可能涉及到以下几个步骤： 1. 初始化线程池：定义线程池大小，创建并启动相应数量的工作线程。 2. 创建任务队列：一个任务可能是读取一个目录名并复制到目标位置，任务会被放入队列中等待执行...
课程设计基于Arm-Linux的可视化文件管理系统源码+项目说明.zip
10-25
线程池：进行多文件、大文件拷贝。 内核链表：用于记录用户进入的路径、检索文件夹下内容、记录选中文件、即将拷贝的文件等操作。 MakeFile 项目管理 【备注】 1、该资源内项目代码都经过测试运行成功，功能ok的...
深入理解Web浏览器与服务器的连接过程
apple_64847327的博客
10-01 617
在互联网的世界里，我们每天都在浏览网页，但你是否想过，当你在浏览器中输入一个网址时，背后发生了什么？
鸿蒙开发（NEXT/API 12）【管理应用与Wear Engine服务的连接状态】手机侧应用开发
鸿蒙的技术博客
10-06 777
华为运动健康App在后台停止服务（如功耗过高），从而导致应用与Wear Engine服务的连接状态发生变化。对于类似这种不确定的断开情况，开发者可以通过本功能特性了解当前应用和Wear Engine的连接状态。前提是在服务断开前，开发者已经使用该功能订阅过对Wear Engine服务连接状态的监测。
ping香港服务器超时的原因通常有哪些？
JttiSEO的博客
09-30 366
解决ping服务器超时的问题通常需要从网络链路的各个环节逐一排查，从本地网络开始，逐步向服务器端和网络路径上的各个节点进行检查。- 跨国路由问题：如果服务器和客户端位于不同国家，数据包可能需要经过多个网络，容易因路由问题导致超时。- 客户端配置问题：客户端的网络配置问题(如错误的IP地址或子网掩码)也可能导致ping请求超时。- 服务器带宽饱和：如果服务器的网络带宽被占满，可能导致新的请求无法及时处理。- 服务器系统问题：操作系统故障或不当的配置可能导致无法响应ping请求。
在 Ubuntu 下通过 Docker 部署 NAS 服务器
shelby_loo的博客
09-30 674
Docker 是一个开源的容器化平台，通过将应用及其依赖打包到容器中，简化了软件的部署与管理。Docker 可以让我们轻松地在任何环境中运行应用，并且可以快速地创建、移动和复制容器。对于 NAS（网络附加存储）软件，最受欢迎的选择之一是。它是一个基于 Debian 的 NAS 解决方案，提供了丰富的功能，如文件共享、备份、用户管理等。通过 Docker 部署 OpenMediaVault，不仅节省系统资源，还能实现快速恢复和轻松升级。
使用树莓派搭建音乐服务器
最新发布
m0_50281408的博客
10-06 769
本人手机存储空间128G，网易云音乐6个G，本就不富裕的空间更是雪上加霜，而且重点是，我根本没有听几首歌，清除缓存后，整个软件都还是占用了5个G左右，正巧，本人最近购入了一块树莓派zero 2w，秉承着不让树莓派变吃灰派的原则，所以萌生出了自己搭建音乐服务器的想法。至此一步就完成了，现在我将网易云常听的歌曲全部传到树莓派中，然后音流中就会扫描，大体的功能也和平常的音乐软件差不多，主要是占空间很小很小，几乎可以忽略不计。
高防服务器的优劣势有哪些？
wanhengwangluo的博客
09-30 484
高防服务器通常都具有强大的DDOS防护能力，对于大规模的恶意流量可以有效过滤和清洗，防止服务器受到网络攻击而出现宕机的现象，确保服务器在面对大流量攻击时，企业的网站和应用能够持续正常运行，提供正常的业务服务。同时高防服务器的配置与管理会更为复杂，需要专业的技术人员进行配置和维护，增加了运营的难度。高防服务器是专门用于防御分布式拒绝服务攻击和其他网络攻击所设计的服务器，高防服务器可以用于保护企业网站和应用不会受到网络攻击，但是高防服务器咋某些方面还是有着一些不足的，下面我们就来一起了解一下吧！
如何初步部署自己的服务器，达到生信分析的及格线
weixin_62528784的博客
09-28 1072
服务器配置1，速战速决
全栈开发者的即时聊天后台项目教程
Netty主要基于Java NIO，并利用了多种技术实现如线程池、复用缓冲区、零拷贝等，以减少不必要的资源消耗，从而达到高性能的目的。 MongoDB是一个面向文档的NoSQL数据库，它提供了高性能、高可用性以及易扩展的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值