linux服务器实现百万并发遇到的问题以及解决思路

news2024/9/20 11:59:44

目录

  • 前言
  • 服务器与客户端的配置介绍
  • server 代码
  • client 代码
  • 遇到的问题
  • error too many open files
    • 为什么会出现这个问题
    • 解决这个问题的思路
  • killed（已杀死）
    • 为什么会出现这个问题
    • 解决这个问题的思路
  • 最终结果
  • 学到的经验教训

前言

在完成百万并发服务器的时候调试了大概五天，期间总会出现莫名其妙的问题导致连接断开，所以本文就这些问题与如何解决这些问题做一个总结。
本次实验完成的百万并发指的是单纯的连接数量，中间只是增加了必要的打印信息而已，并未增加具体的业务信息。

服务器与客户端的配置介绍

server（1台）：ubuntu20.04 8G8核
client（3台）：ubuntu16.04 4G2核

server 代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/poll.h>

#include <errno.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>

#include <pthread.h>

#define SERVER_PORT		8080
#define SERVER_IP		"127.0.0.1"
#define MAX_BUFFER		64
#define MAX_EPOLLSIZE	100000
#define MAX_THREAD		80
#define MAX_PORT		100

#define CPU_CORES_SIZE	8

#define TIME_SUB_MS(tv1, tv2)  ((tv1.tv_sec - tv2.tv_sec) * 1000 + (tv1.tv_usec - tv2.tv_usec) / 1000)

static int ntySetNonblock(int fd) {
	int flags;

	flags = fcntl(fd, F_GETFL, 0);
	if (flags < 0) return flags;
	flags |= O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags) < 0) return -1;
	return 0;
}

static int ntySetReUseAddr(int fd) {
	int reuse = 1;
	return setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(reuse));
}

static int ntySetAlive(int fd) {
	int alive = 1;
	int idle = 60;
	int interval = 5;
	int count = 2;

	setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&alive, sizeof(alive));
	setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, (void*)&idle, sizeof(idle));
	setsockopt(fd, SOL_TCP, TCP_KEEPINTVL, (void*)&interval, sizeof(interval));
	setsockopt(fd, SOL_TCP, TCP_KEEPCNT, (void*)&count, sizeof(count));
}


/** **** ******** **************** thread pool **************** ******** **** **/

#define LL_ADD(item, list) { \
	item->prev = NULL; \
	item->next = list; \
	list = item; \
}

#define LL_REMOVE(item, list) { \
	if (item->prev != NULL) item->prev->next = item->next; \
	if (item->next != NULL) item->next->prev = item->prev; \
	if (list == item) list = item->next; \
	item->prev = item->next = NULL; \
}

typedef struct worker {	
	pthread_t thread;	
	int terminate;	
	struct workqueue *workqueue;	
	struct worker *prev;	
	struct worker *next;
} worker_t;

typedef struct job {	
	void (*job_function)(struct job *job);	
	void *user_data;	
	struct job *prev;	
	struct job *next;
} job_t;

typedef struct workqueue {	
	struct worker *workers;	
	struct job *waiting_jobs;	
	pthread_mutex_t jobs_mutex;	
	pthread_cond_t jobs_cond;
} workqueue_t;


static void *worker_function(void *ptr) {	
	worker_t *worker = (worker_t *)ptr;	
	job_t *job;	

	while (1) {			
		pthread_mutex_lock(&worker->workqueue->jobs_mutex);		
		while (worker->workqueue->waiting_jobs == NULL) {			
			if (worker->terminate) break;			
			pthread_cond_wait(&worker->workqueue->jobs_cond, &worker->workqueue->jobs_mutex);		
		}			
		if (worker->terminate) break;		
		job = worker->workqueue->waiting_jobs;		
		if (job != NULL) {			
			LL_REMOVE(job, worker->workqueue->waiting_jobs);		
		}		
		pthread_mutex_unlock(&worker->workqueue->jobs_mutex);		
			
		if (job == NULL) continue;	
		
		/* Execute the job. */		
		job->job_function(job);	
	}	
	
	free(worker);	
	pthread_exit(NULL);
}

int workqueue_init(workqueue_t *workqueue, int numWorkers) {	
	int i;	
	worker_t *worker;	
	pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER;	
	pthread_mutex_t blank_mutex = PTHREAD_MUTEX_INITIALIZER;	

	if (numWorkers < 1) numWorkers = 1;	
	
	memset(workqueue, 0, sizeof(*workqueue));	
	memcpy(&workqueue->jobs_mutex, &blank_mutex, sizeof(workqueue->jobs_mutex));	
	memcpy(&workqueue->jobs_cond, &blank_cond, sizeof(workqueue->jobs_cond));	

	for (i = 0; i < numWorkers; i++) {		
		if ((worker = malloc(sizeof(worker_t))) == NULL) {			
			perror("Failed to allocate all workers");			
			return 1;		
		}		

		memset(worker, 0, sizeof(*worker));		
		worker->workqueue = workqueue;		
		
		if (pthread_create(&worker->thread, NULL, worker_function, (void *)worker)) {			
			perror("Failed to start all worker threads");			
			free(worker);			
			return 1;		
		}		

		LL_ADD(worker, worker->workqueue->workers);	
	}	

	return 0;
}


void workqueue_shutdown(workqueue_t *workqueue) {	

	worker_t *worker = NULL;		
	for (worker = workqueue->workers; worker != NULL; worker = worker->next) {		
		worker->terminate = 1;	
	}	


	pthread_mutex_lock(&workqueue->jobs_mutex);	
	workqueue->workers = NULL;	
	workqueue->waiting_jobs = NULL;	
	pthread_cond_broadcast(&workqueue->jobs_cond);	
	pthread_mutex_unlock(&workqueue->jobs_mutex);

}


void workqueue_add_job(workqueue_t *workqueue, job_t *job) {	

	pthread_mutex_lock(&workqueue->jobs_mutex);	

	LL_ADD(job, workqueue->waiting_jobs);	

	pthread_cond_signal(&workqueue->jobs_cond);	
	pthread_mutex_unlock(&workqueue->jobs_mutex);

}

static workqueue_t workqueue;
void threadpool_init(void) {
	workqueue_init(&workqueue, MAX_THREAD);
}


/** **** ******** **************** thread pool **************** ******** **** **/

typedef struct client {
	int fd;
	char rBuffer[MAX_BUFFER];
	int length;
} client_t;

void *client_cb(void *arg) {
	int clientfd = *(int *)arg;
	char buffer[MAX_BUFFER] = {0};

	int childpid = getpid();

	while (1) {
		bzero(buffer, MAX_BUFFER);
		ssize_t length = recv(clientfd, buffer, MAX_BUFFER, 0); //bio
		if (length > 0) {
			//printf(" PID:%d --> buffer: %s\n", childpid, buffer);

			int sLen = send(clientfd, buffer, length, 0);
			//printf(" PID:%d --> sLen: %d\n", childpid, sLen);
		} else if (length == 0) {
			printf(" PID:%d client disconnect\n", childpid);
			break;
		} else {
			printf(" PID:%d errno:%d\n", childpid, errno);
			break;
		}
	}
}


static int nRecv(int sockfd, void *data, size_t length, int *count) {
	int left_bytes;
	int read_bytes;
	int res;
	int ret_code;

	unsigned char *p;

	struct pollfd pollfds;
	pollfds.fd = sockfd;
	pollfds.events = ( POLLIN | POLLERR | POLLHUP );

	read_bytes = 0;
	ret_code = 0;
	p = (unsigned char *)data;
	left_bytes = length;

	while (left_bytes > 0) {

		read_bytes = recv(sockfd, p, left_bytes, 0);
		if (read_bytes > 0) {
			left_bytes -= read_bytes;
			p += read_bytes;
			continue;
 		} else if (read_bytes < 0) {
			if (!(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)) {
				ret_code = (errno != 0 ? errno : EINTR);
			}
		} else {
			ret_code = ENOTCONN;
			break;
		}
		
		res = poll(&pollfds, 1, 5);
		if (pollfds.revents & POLLHUP) {
			ret_code = ENOTCONN;
			break;
		}
		if (res < 0) {
			if (errno == EINTR) {
				continue;
			}
			ret_code = (errno != 0 ? errno : EINTR);
		} else if (res == 0) {
			ret_code = ETIMEDOUT;
			break;
		}

	}

	if (count != NULL) {
		*count = length - left_bytes;
	}
	//printf("nRecv:%s, ret_code:%d, count:%d\n", (char*)data, ret_code, *count);


	return ret_code;
}

void epoll_et_loop(int sockfd)
{
    char buffer[MAX_BUFFER];
    int ret;

    while (1)
    {
        memset(buffer, 0, MAX_BUFFER);
        ret = recv(sockfd, buffer, MAX_BUFFER, 0);
        if (ret == -1)
        {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
            {
                printf(" read all data\n");
                break;
            }
            close(sockfd);
            break;
        }
        else if (ret == 0)
        {
            printf(" disconnect\n");
            close(sockfd);
            break;
        }
        else
            printf("Recv:%s, %d Bytes\n", buffer, ret);
    }
    
}

static int nSend(int sockfd, const void *buffer, int length, int flags) {

	int wrotelen = 0;
	int writeret = 0;

	unsigned char *p = (unsigned char *)buffer;

	struct pollfd pollfds = {0};
	pollfds.fd = sockfd;
	pollfds.events = ( POLLOUT | POLLERR | POLLHUP );

	do {
		int result = poll( &pollfds, 1, 5);
		if (pollfds.revents & POLLHUP) {
			
			printf(" ntySend errno:%d, revent:%x\n", errno, pollfds.revents);
			return -1;
		}

		if (result < 0) {
			if (errno == EINTR) continue;

			printf(" ntySend errno:%d, result:%d\n", errno, result);
			return -1;
		} else if (result == 0) {
		
			printf(" ntySend errno:%d, socket timeout \n", errno);
			return -1;
		}

		writeret = send( sockfd, p + wrotelen, length - wrotelen, flags );
		if( writeret <= 0 )
		{
			break;
		}
		wrotelen += writeret ;

	} while (wrotelen < length);
	
	return wrotelen;
}


static int curfds = 1;
static int nRun = 0;
	

void client_job(job_t *job) {


	client_t *rClient = (client_t*)job->user_data;
	int clientfd = rClient->fd;

	char buffer[MAX_BUFFER];
	bzero(buffer, MAX_BUFFER);

	int length = 0;
	int ret = nRecv(clientfd, buffer, MAX_BUFFER, &length);
	if (length > 0) {	
		if (nRun || buffer[0] == 'a') {		
			printf(" TcpRecv --> curfds : %d, buffer: %s\n", curfds, buffer);
			
			nSend(clientfd, buffer, strlen(buffer), 0);
		}

	} else if (ret == ENOTCONN) {
		curfds --;
		close(clientfd);
	} else {
		
	}

	free(rClient);
	free(job);
}

void client_data_process(int clientfd) {

	char buffer[MAX_BUFFER];
	bzero(buffer, MAX_BUFFER);
	int length = 0;
	int ret = nRecv(clientfd, buffer, MAX_BUFFER, &length);
	if (length > 0) {	
		if (nRun || buffer[0] == 'a') {		
			printf(" TcpRecv --> curfds : %d, buffer: %s\n", curfds, buffer);
			
			nSend(clientfd, buffer, strlen(buffer), 0);
		}

	} else if (ret == ENOTCONN) {
		curfds --;
		close(clientfd);
	} else {
		
	}

}



int listenfd(int fd, int *fds) {
	int i = 0;

	for (i = 0;i < MAX_PORT;i ++) {
		if (fd == *(fds+i)) return *(fds+i);
	}
	return 0;
}

int main(void) {
	int i = 0;
	int sockfds[MAX_PORT] = {0};

	printf("C1000K Server Start\n");
	
	threadpool_init(); //

	int epoll_fd = epoll_create(MAX_EPOLLSIZE); 

	for (i = 0;i < MAX_PORT;i ++) {

		int sockfd = socket(AF_INET, SOCK_STREAM, 0);
		if (sockfd < 0) {
			perror("socket");
			return 1;
		}

		struct sockaddr_in addr;
		memset(&addr, 0, sizeof(struct sockaddr_in));
		
		addr.sin_family = AF_INET;
		addr.sin_port = htons(SERVER_PORT+i);
		addr.sin_addr.s_addr = INADDR_ANY;

		if (bind(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
			perror("bind");
			return 2;
		}

		if (listen(sockfd, 5) < 0) {
			perror("listen");
			return 3;
		}

		sockfds[i] = sockfd;
		printf("C1000K Server Listen on Port:%d\n", SERVER_PORT+i);

		struct epoll_event ev;
		 
		ev.events = EPOLLIN | EPOLLET; //EPOLLLT
		ev.data.fd = sockfd;
		epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &ev);  
	}

	struct timeval tv_begin;
	gettimeofday(&tv_begin, NULL);
	
	struct epoll_event events[MAX_EPOLLSIZE];

	while (1) {

		int nfds = epoll_wait(epoll_fd, events, curfds, 5);  //是不是秘书给累死。
		if (nfds == -1) {
			perror("epoll_wait");
			break;
		}
		for (i = 0;i < nfds;i ++) {

			int sockfd = listenfd(events[i].data.fd, sockfds);
			if (sockfd) {
				struct sockaddr_in client_addr;
				memset(&client_addr, 0, sizeof(struct sockaddr_in));
				socklen_t client_len = sizeof(client_addr);
				
				int clientfd = accept(sockfd, (struct sockaddr*)&client_addr, &client_len);
				if (clientfd < 0) {
					perror("accept");
					return 4;
				}
				
				if (curfds ++ > 1000 * 1000) {
					nRun = 1;
				}
#if 0
				printf(" Client %d: %d.%d.%d.%d:%d \n", curfds, *(unsigned char*)(&client_addr.sin_addr.s_addr), *((unsigned char*)(&client_addr.sin_addr.s_addr)+1),													
							*((unsigned char*)(&client_addr.sin_addr.s_addr)+2), *((unsigned char*)(&client_addr.sin_addr.s_addr)+3),													
							client_addr.sin_port);
#elif 0
				if(curfds % 1000 == 999) {	
					printf("connections: %d, fd: %d\n", curfds, clientfd);			
				}
#else
				if (curfds % 1000 == 999) {
					struct timeval tv_cur;
					memcpy(&tv_cur, &tv_begin, sizeof(struct timeval));
					
					gettimeofday(&tv_begin, NULL);

					int time_used = TIME_SUB_MS(tv_begin, tv_cur);
					printf("connections: %d, sockfd:%d, time_used:%d\n", curfds, clientfd, time_used);
				}
#endif
				ntySetNonblock(clientfd);
				ntySetReUseAddr(clientfd);

				struct epoll_event ev;
				ev.events = EPOLLIN | EPOLLET | EPOLLOUT;
				ev.data.fd = clientfd;
				epoll_ctl(epoll_fd, EPOLL_CTL_ADD, clientfd, &ev);

			} else {

				int clientfd = events[i].data.fd;
#if 1
				if (nRun) {
					printf(" New Data is Comming\n");
					client_data_process(clientfd);
				} else {
			
					client_t *rClient = (client_t*)malloc(sizeof(client_t));
					memset(rClient, 0, sizeof(client_t));				
					rClient->fd = clientfd;
					
					job_t *job = malloc(sizeof(job_t));
					job->job_function = client_job;
					job->user_data = rClient;
					workqueue_add_job(&workqueue, job);
					
					
				}
#else
				client_data_process(clientfd);
				
#endif
			}
		}
		
	}
}

client 代码



#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <errno.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>


#define MAX_BUFFER		128
#define MAX_EPOLLSIZE	(384*1024)
#define MAX_PORT		100

#define TIME_SUB_MS(tv1, tv2)  ((tv1.tv_sec - tv2.tv_sec) * 1000 + (tv1.tv_usec - tv2.tv_usec) / 1000)

int isContinue = 0;

static int ntySetNonblock(int fd) {
	int flags;

	flags = fcntl(fd, F_GETFL, 0);
	if (flags < 0) return flags;
	flags |= O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags) < 0) return -1;
	return 0;
}

static int ntySetReUseAddr(int fd) {
	int reuse = 1;
	return setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(reuse));
}



int main(int argc, char **argv) {
	if (argc <= 2) {
		printf("Usage: %s ip port\n", argv[0]);
		exit(0);
	}

	const char *ip = argv[1];
	int port = atoi(argv[2]);
	int connections = 0;
	char buffer[128] = {0};
	int i = 0, index = 0;

	struct epoll_event events[MAX_EPOLLSIZE];
	
	int epoll_fd = epoll_create(MAX_EPOLLSIZE);
	
	strcpy(buffer, " Data From MulClient\n");
		
	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(struct sockaddr_in));
	
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = inet_addr(ip);

	struct timeval tv_begin;
	gettimeofday(&tv_begin, NULL);

	while (1) {
		if (++index >= MAX_PORT) index = 0;
		
		struct epoll_event ev;
		int sockfd = 0;

		if (connections < 380000 && !isContinue) {
			sockfd = socket(AF_INET, SOCK_STREAM, 0);
			if (sockfd == -1) {
				perror("socket");
				goto err;
			}

			//ntySetReUseAddr(sockfd);
			addr.sin_port = htons(port+index);

			if (connect(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
				perror("connect");
				goto err;
			}
			ntySetNonblock(sockfd);
			ntySetReUseAddr(sockfd);

			sprintf(buffer, "Hello Server: client --> %d\n", connections);
			send(sockfd, buffer, strlen(buffer), 0);

			ev.data.fd = sockfd;
			ev.events = EPOLLIN | EPOLLOUT;
			epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &ev);
		
			connections ++;
		}
		//connections ++;
		if (connections % 1000 == 999 || connections >= 380000) {
			struct timeval tv_cur;
			memcpy(&tv_cur, &tv_begin, sizeof(struct timeval));
			
			gettimeofday(&tv_begin, NULL);

			int time_used = TIME_SUB_MS(tv_begin, tv_cur);
			printf("connections: %d, sockfd:%d, time_used:%d\n", connections, sockfd, time_used);

			int nfds = epoll_wait(epoll_fd, events, connections, 100);
			for (i = 0;i < nfds;i ++) {
				int clientfd = events[i].data.fd;

				if (events[i].events & EPOLLOUT) {
					sprintf(buffer, "data from %d\n", clientfd);
					send(sockfd, buffer, strlen(buffer), 0);
				} else if (events[i].events & EPOLLIN) {
					char rBuffer[MAX_BUFFER] = {0};				
					ssize_t length = recv(sockfd, rBuffer, MAX_BUFFER, 0);
					if (length > 0) {
						printf(" RecvBuffer:%s\n", rBuffer);

						if (!strcmp(rBuffer, "quit")) {
							isContinue = 0;
						}
						
					} else if (length == 0) {
						printf(" Disconnect clientfd:%d\n", clientfd);
						connections --;
						close(clientfd);
					} else {
						if (errno == EINTR) continue;

						printf(" Error clientfd:%d, errno:%d\n", clientfd, errno);
						close(clientfd);
					}
				} else {
					printf(" clientfd:%d, errno:%d\n", clientfd, errno);
					close(clientfd);
				}
			}
		}

		usleep(1 * 1000);
	}

	return 0;

err:
	printf("error : %s\n", strerror(errno));
	return 0;
}

遇到的问题

error too many open files

在这里插入图片描述

为什么会出现这个问题

因为是文件系统默认允许打开文件描述符数量个数（默认1024）的限制，使用ulimit -a查看open files的数量

ulimit -a

在这里插入图片描述
查看一个进程能够打开的文件描述符数量： ulimit -a

 ulimit -a	
 # 可以看到 open files 是1024，所以我们进行调大到 1048576

在这里插入图片描述

解决这个问题的思路

修改对应的可以打开的文件描述符的数量即可。

1.临时修改：ulimit -n 1048576
2.永久修改：按照下面的操作即可

vim /etc/security/limits.conf

# 在该配置文件的最后添加如下内容即可
*               soft    nofile          1048576
*               hard    nofile          1048576
# esc+:wq保存文件

#重启机器
reboot

killed（已杀死）

此时已经很接近了！！还是出现问题。
在这里插入图片描述

为什么会出现这个问题

此时是因为内存不够了。

解决这个问题的思路

修改net.ipv4.tcp_mem，net.ipv4.tcp_wmem，net.ipv4.tcp_rmem的大小即可。
server：

vim  vim /etc/sysctl.conf

#移动到配置文件最末位的位置
net.ipv4.tcp_mem = 252144 524288 786432
net.ipv4.tcp_wmem = 512 512 1024
net.ipv4.tcp_rmem = 512 512 1024
fs.file-max = 1048576
net.nf_conntrack_max = 1048576

#esc+ :wq保存

#执行如下操作：
sudo modprobe ip_conntrack
sysctl -p

在这里插入图片描述

client：

vim  vim /etc/sysctl.conf

#移动到配置文件最末位的位置
net.ipv4.tcp_mem = 252144 524288 786432
net.ipv4.tcp_wmem = 1024 1024 2048
net.ipv4.tcp_rmem = 1024 1024 2048
fs.file-max = 1048576
net.nf_conntrack_max = 1048576


#esc+ :wq保存

#执行如下操作：
sudo modprobe ip_conntrack
sysctl -p

在这里插入图片描述

最终结果

将以上配置好之后再次执行程序即可得到如下结果。
在这里插入图片描述
在这里插入图片描述

学到的经验教训

理论与实践有很大的差别，不要眼高手低，要多多调试，真真正正的将程序敲出来。

文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习: 链接

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/453760.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

搭建家庭影音媒体中心 - 公网远程连接Jellyfin流媒体服务器

搭建家庭影音媒体中心 - 公网远程连接Jellyfin流媒体服务器

文章目录 前言1. 安装Home Assistant2. 配置Home Assistant3. 安装cpolar内网穿透3.1 windows系统3.2 Linux系统3.3 macOS系统 4. 映射Home Assistant端口5. 公网访问Home Assistant6. 固定公网地址6.1 保留一个固定二级子域名6.2 配置固定二级子域名 转载自远程穿透的文章&…
阅读更多...
MySQL高级第十六篇：数据库日志有哪些（慢查询日志、通用查询日志、错误日志和二进制日志）

MySQL高级第十六篇：数据库日志有哪些（慢查询日志、通用查询日志、错误日志和二进制日志）

MySQL高级第十六篇&#xff1a;数据库日志有哪些&#xff08;慢查询日志、通用查询日志、错误日志和二进制日志&#xff09; 一、MySQL支持的日志有哪些&#xff1f;1. 日志类型总结2. 日志有什么缺点吗&#xff1f; 二、通用查询日志&#xff08;slow query log&#xff09;三…
阅读更多...
【开发工具】idea2023.1社区版设置优化，媲美旗舰版

【开发工具】idea2023.1社区版设置优化，媲美旗舰版

相信大家很多时候都是用旗舰版来开发&#xff0c;各种序列号破解包各种搞&#xff0c;但说不定哪天又失效了那天又爆泄漏隐私安全问题。随着idea的版本升级破解也不好搞了&#xff0c;所以我就直接用了社区版&#xff0c;经过一番折腾发现社区版一点不比旗舰版差&#xff0c;可…
阅读更多...
Linux文件类型与属性

Linux文件类型与属性

一、文件类型 Linux 系统下一共分为 7 种文件类型。通过 stat 命令或者 ls 命令来查看文件类型。 - &#xff1a;普通文件 d &#xff1a;目录文件 c &#xff1a;字符设备文件 b &#xff1a;块设备文件 l &#xff1a;符号链接文件 s &#xff1a;套接字文件 p &…
阅读更多...
Jeston NANO 配置并安装 torch+ torchvision

Jeston NANO 配置并安装 torch+ torchvision

由于nano的arm64架构&#xff0c;所以用它进行深度学习配置部署时会与用普通电脑&#xff08;x86&#xff09;有所不同: x86架构 x86架构是最常用的计算机架构之一&#xff0c;它是基于英特尔的8086处理器所设计的&#xff0c;后来又逐渐发展成x86-64架构&#xff0c;支持64位处…
阅读更多...
开放原子训练营（第二季）RT-Thread Nano学习营刘玉宽

开放原子训练营（第二季）RT-Thread Nano学习营刘玉宽

4月22日周六&#xff0c;早早起床充满期待的来到了北京艾丽华酒店&#xff0c;参加“2023年RT-Thread线下培训”。这是疫情三年以来开放原子在北京第一次组织的线下活动。 进入到会场&#xff0c;被震撼了&#xff0c;好火爆啊————满满一屋子人&#xff0c;有白发苍苍的老者…
阅读更多...
MySQL运维36-排队论

MySQL运维36-排队论

文章目录 1、排队模型2、什么是排队论3、李特尔法则&#xff08;Little’s law&#xff09;3.1、李特尔法则的内容3.2、李特尔法则的意义 4、肯德尔排队表示法4.1、肯德尔表示法的核心要素A/S/m4.2、肯德尔表示法中对顾客达到分布的表示&#xff1a;4.3、用肯德尔表示法表示的常…
阅读更多...
day03_注释丶关键字丶标识符丶常量

day03_注释丶关键字丶标识符丶常量

​注释 注释的概念&#xff1a;在编写程序的过程中&#xff0c;对程序代码进行解释说明。 代码本身和人类的自然语言相比&#xff0c;可读性肯定是要差一些&#xff0c;所以为了更快能够知道代码的含义、作用、需要注意地方&#xff0c;所有程序员都应该养成写注释的好习惯。 …
阅读更多...
【安卓源码】Binder机制1-Servicemanager 进程的启动和defaultServiceManager

【安卓源码】Binder机制1-Servicemanager 进程的启动和defaultServiceManager

1. servicemanager 进程的启动 对于用户空间&#xff0c;不同进程之间彼此是不能共享的&#xff0c;而内核空间却是可共享的。Client进程向Server进程通信&#xff0c;恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的&#xff0c;Client端与Server端进程往往采用io…
阅读更多...
Linux客观题错题笔记

Linux客观题错题笔记

目录 第一章课后测试 课堂测试一 课堂测试2 第二次课后测试 课堂测验4 第4次课后作业 Linux 课堂测试5 第五次课后测试 自测一 实验疑难点 第一章课后测试 a 课堂测试一 d 课堂测试2 bb 第二次课后测试 a , b c,d,c 课堂测验4 a 第4次课后作业 c.dc,c Lin…
阅读更多...
自动化测试系列-Selenium三种等待详解

自动化测试系列-Selenium三种等待详解

一. 强制等待 sleep 在华为工作了10年的大佬出的Web自动化测试教程&#xff0c;华为现用技术教程&#xff01;_哔哩哔哩_bilibili在华为工作了10年的大佬出的Web自动化测试教程&#xff0c;华为现用技术教程&#xff01;共计16条视频&#xff0c;包括&#xff1a;1. 【web自动…
阅读更多...
[POJ - 1015]Jury Compromise（01背包问题）

[POJ - 1015]Jury Compromise（01背包问题）

[POJ - 1015]Jury Compromise&#xff08;01背包问题&#xff09; 一、问题二、分析1、状态表示2、状态转移3、方案输出 三、代码 一、问题 二、分析 这道题可以转化为一个01背包问题&#xff0c;问题描述可以改为&#xff0c;每个物品具有两个属性 a a a和 b b b&#xff0c;…
阅读更多...
异构系统的事务统一处理模型Saga

异构系统的事务统一处理模型Saga

承接上文分布式事务Seata-TCC事务模式 Saga事务模式相对来说是最复杂的&#xff0c;用的不多&#xff0c;只需要把概念理解透就可以了。 Saga是Seata提供的长事务解决方案&#xff0c;在业务流程中每个参与者都提供本地事务&#xff0c;当出现某个参与者失败的情况则补偿前面已…
阅读更多...
如何设计一个牛逼的API接口

如何设计一个牛逼的API接口

在日常开发中&#xff0c;总会接触到各种接口。前后端数据传输接口&#xff0c;第三方业务平台接口。一个平台的前后端数据传输接口一般都会在内网环境下通信&#xff0c;而且会使用安全框架&#xff0c;所以安全性可以得到很好的保护。这篇文章重点讨论一下提供给第三方平台的…
阅读更多...
[自注意力神经网络]Mask Transfiner网络-论文解读

[自注意力神经网络]Mask Transfiner网络-论文解读

本文为CVPR2022的论文。国际惯例&#xff0c;先贴出原文和源码&#xff1a; 原论文地址https://arxiv.org/pdf/2111.13673.pdf源码地址https://github.com/SysCV/transfiner 一、概述 传统的Two-Stage网络&#xff0c;如Mask R-CNN虽然在实例分割上取得了较好的效果&#xff…
阅读更多...
OSCP-Twiggy（ZeroMQ、SaltStack）

OSCP-Twiggy（ZeroMQ、SaltStack）

目录 扫描 ​编辑WEB 扫描 WEB 80端口 运行着一个名为Mezzanine的东西。快速的谷歌搜索显示这是一个内容管理系统，所以让我们看看它是否对任何可以在我们的目标机器上获得shell的东西都是脆弱的： mezzanine版本是4.3.1，并且此漏洞已在4.2.1中修补。 searchsploit没有返回…
阅读更多...
说说MySQL中MVCC机制的原理

说说MySQL中MVCC机制的原理

一、概述&#xff1a; 了解了MySql的底层架构后&#xff0c;我们今天要深入了解下什么是MVCC。 MVCC&#xff0c;全称Multi-Version Concurrency Control&#xff0c;即多版本并发控制。MVCC是一种多并发控制的方法&#xff0c;一般在数据库管理系统中&#xff0c;实现对数据…
阅读更多...
NAS私有云存储 - 搭建Nextcloud私有云盘并公网远程访问

NAS私有云存储 - 搭建Nextcloud私有云盘并公网远程访问

文章目录 摘要视频教程1. 环境搭建2. 测试局域网访问3. 内网穿透3.1 ubuntu本地安装cpolar3.2 创建隧道3.3 测试公网访问 4 配置固定http公网地址4.1 保留一个二级子域名4.1 配置固定二级子域名4.3 测试访问公网固定二级子域名 转载自内网穿透工具的文章&#xff1a;使用Nextcl…
阅读更多...
LVS负载均衡集群

LVS负载均衡集群

引言 如今&#xff0c;在各种互联网应用中&#xff0c;随着站点对硬件性能、响应速度、服务稳定性、数据可靠性等要求也越来越高&#xff0c;单台服务器也将难以无法承担所有的访问需求。 一、群集的含义 集群、群集 由多台主机构成&#xff0c;但对外&#xff0c;只表现为一…
阅读更多...
ubuntu-18.0.04 鸿蒙HarmonyOS系统源码(HOSP)下载

ubuntu-18.0.04 鸿蒙HarmonyOS系统源码(HOSP)下载

最近小编在研究鸿蒙开发&#xff0c;想要研究下鸿蒙源码&#xff0c;这里记录下源码下载中遇到的问题及解决&#xff0c;也为HarmonyOS的生态的建设提供下帮助&#xff0c;希望能帮到需要的人。 前置步骤&#xff1a;如果你之前下载过AOSP源码&#xff0c;那这里下载鸿蒙源码应…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023