linux-并发通信

一.linux-tcp通信框架

1.基础框架

1.1 tcp 服务器框架

1.套接字
#include <sys/socket.h>
int socket(int domain, int type, int protocol);


返回的文件描述符可以指向当前的socket，后续通过对文件描述符的访问就可以配置这个socket 

成功时返回文件描述符，失败时返回-1。

●domain 套接字中使用的协议族（ProtocolFamily）信息。

●type 套接字数据传输类型信息。（（SOCK_STREAM）---TCP，（SOCKDGRAM）---UDP）

●protocol 计算机间通信中使用的协议信息。  

2.bind 函数

如果把套接字比喻为电话，那么创建套接字只安装了电话机。 接着就要给电话机分配号码的方法，即给套接字分配 IP地址和端口号。就是用的bind函数。 

#include<sys/socket.h>
int bind(int sockfd, struct sockaddr *myaddr, socklen_t addrlen);

参数一：套接字描述符 sockfd 要分配地址信息（IP地址和端口号）的套接字文件描述符。

参数二：myaddr 存有地址信息的结构体变量地址值 

struct sockaddr   
{  
    unsigned short sa_family;    //2 
    char sa_data[14];     //14
};  
struct in_addr
{
    In_addr_t s_addr; //32 位 IPv4 地址
};

struct sockaddr_in
 {
    sa_family//地址族（Address Family）
    sa_family_t sin_family;// //地址族（Address Family）
    uint16_t sin_port; // 16 位 TCP/UDP 端口号
    struct in_addr sin_addr; //32 位 IP 地址
    char sin_zero[8]; //不使用
}

这里我们使用scokaddr_in来配置端口和ip（参数填写更方便），然后转换为socketadrr就行，两个结构体可以互相转换的

参数三：第二个结构体变量的长度

示例配置如下：

struct sockaddr_in addr;
char* serv_ip="211.217.168.13";
 //声明 IP地址字符串
char * serv_port="9198"; //声明端口号字符串
memset(&addr,0,sizeof(addr);//结构体变量 addr 的所有成员初始化为 0
 //指定地址族
addr.sin_family =AF_INET;
 //基于字符串的IP地址初始化
//inet用于将点分十进制的IP地址字符串转换成网络字节顺序（big-endian）的整数表示形式。
addr.sin_addr.s_addr=inet_addr(serv_ip);
 //基于字符串的端口号初始化
//atoi字符型转换为整型
addr.sin_port=htons(atoi(serv_port));
3.listen 函数：
#include <sys/socket.h>
int listen(int sock,int backlog);

sock 希望进入等待连接请求状态的套接字文件描述符

  • 传递的描述符套接字参数成为服务器端 套接字（监听套接字）。
  • backlog 连接请求等待队列（Queue）的长度，若为5，则队列长度为5，表示最多使5个连 接请求进入队列。
 4.accept 函数：
#include<sys/socket.h>
int accept(int sock,struct sockaddr * addr, socklen_t*addrlen);

成功时返回创建的套接字文件描述符，失败时返回-1。

  • 参数sock:服务器套接字的文件描述符。
  • 参数addr:保存发起连接请求的客户端地址信息的变量地址值，调用函数后向传递来的地址变量参数填充客户端地址信息。
  • 参数addrlen：第二个参数结构体的长度，但是存有长度的变量地址。函数调用完成后，该变量即被填客户端地址长度。

 accept 函数受理连接请求等待队列中待处理的客户端连接请求。函数调用成功时，accept函数内部将产生用于数据I/O的套接字，并返回其文件描述符。套接字是自动创建的，并自 动与发起连接请求的客户端建立连接。上图展示了accept函数调用过程。

5. tcp 服务端框架
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

int main(){
    int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;  
/*
在网络编程中，一个服务器可能有多个网络接口（即多个IP地址）。如果你指定了一个具体的
IP地址来绑socket，那么服务器程序只能接受发送到这个特定IP地址的连接请求。相反，
使用INADDR_ANY可以让服务接受到达服务器上任何网络接口的连接请求，
这样就不需要针对每个可能的IP地址分别设置监听了。
*/
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);  
    serv_addr.sin_port = htons(9190);  

    bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    listen(serv_sock, 20);
//用于生成客户端套接字，中间需要使用一个addr结构体，我们创建一个空结构体传入
accept辅助完成socket创建
    struct sockaddr_in clnt_addr;
    socklen_t clnt_addr_size = sizeof(clnt_addr);
//accept后会创建一个套接字，
    int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);

    char message[] = "Hello, World!";
    write(clnt_sock, message, sizeof(message));

    close(clnt_sock);  
    close(serv_sock);  

    return 0;
}

1.2 tcp 客户端框架

1.connect
#include<sys/socket.h>
int connect(int sock,struct sockaddr*servaddr, socklen_t addrlen);

成功时返回0，失败时返回-1。

  • sock 客户端套接字文件描述符。
  • servaddr 保存目标服务器端地址信息的变量地址值。
  • addrlen 以字节为单位传递给第二个结构体参数servaddr的地址变量长度。
2.客户端框架 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

int main(){
    int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));  
    serv_addr.sin_family = AF_INET;  
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  
    serv_addr.sin_port = htons(9190);  
//
    connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

    char buffer[40];
    read(sock, buffer, sizeof(buffer)-1);

    printf("Message from server: %s\n", buffer);

    close(sock);
    return 0;
}

1.3 线程基础

1.线程创建
#include<pthread.h>
int pthread_create(
     pthread_t*restrict thread,
     const pthread_attr_t * restrict attr,
     void *(* start_routine)(void *),
     void*restrict arg
);

成功时返回 0，失败时返回其他值。

●thread：保存新创建线程ID的变量地址值。线程与进程相同，也需要用于区分不同线程的ID。

●attr：用于传递线程属性的参数，传递NULL时，创建默认属性的线程。

●start_routine：相当于线程main函数的、在单独执行流中执行的函数地址值（函数指针）。

●arg：通过第三个参数传递调用函数时包含传递参数信息的变量地址值。

#include<pthread.h>
int pthread_join(pthread_t thread, void ** status);

 调用pthread_join 函数的进程（或线程）将进入等待状态，直到第一个参数为ID的线程终 止为止。而且可以得到线程的main函数返回值，所以该函数比较有用。下面通过示例了解 该函数的功能。

成功时返回e，失败时返回其他值。

  • thread 该参数值ID的线程终止后才会从该函数返回。
  • status保存线程的main函数返回值的 指针变量地址值。
2.互斥锁
#include<pthread.h>
int pthread_mutex_init(pthread mutex_t*mutex, const pthread_mutexattr_t* attr);
int pthread_mutex_destroy(pthread_mutex_t * mutex);
  • mutex 创建互斥量时传递保存互斥量的变量地址值，销毁时传递需要销毁的互斥量地址值。
  • attr传递即将创建的互斥量属性，没有特别需要指定的属性时传递NULL。
#include<pthread.h>
int pthread_mutex_lock(pthread_mutex_t* mutex);
int pthread_mutex_unlock(pthread mutex_t* mutex);

成功时返回0，失败时返回其他值。

使用方法：

pthread_mutex_lock(&mutex);
 //临界区的开始
//.....
 // 临界区的结束
pthreadmutex_unlock(&mutex);

线程使用实例：

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

// 全局变量作为共享资源
int shared_resource = 0;
// 互斥量对象
pthread_mutex_t mutex;

// 线程函数，递增共享资源
void* thread_func(void* arg) {
    for(int i = 0; i < 10000; ++i) {
        // 锁定互斥量
        pthread_mutex_lock(&mutex);
        // 访问并修改共享资源
        shared_resource++;
        // 解锁互斥量
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 初始化互斥量
    pthread_mutex_init(&mutex, NULL);

    // 创建两个线程
    pthread_create(&thread1, NULL, thread_func, NULL);
    pthread_create(&thread2, NULL, thread_func, NULL);

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 打印共享资源的最终值
    printf("Final value of shared resource: %d\n", shared_resource);

    // 销毁互斥量
    pthread_mutex_destroy(&mutex);

    return 0;
}

二、并发服务器

2.1 多线程服务器实现

1.服务器端：

每次accept都阻塞，来一个连接，就创建一个线程进行处理，多线程互不干扰 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#define BUF_SIZE 100
#define MAX_CLNT 256
void* handle_clnt(void* arg);
void send_msg(char* msg, int len);
void error_handling(char* msg);
int clnt_cnt = 0;
int clnt_socks[MAX_CLNT];
pthread_mutex_t mutx;
int main(int argc, char* argv[])
{
	int serv_sock, clnt_sock;
	struct sockaddr_in serv_adr, clnt_adr;
	int clnt_adr_sz;
	pthread_t t_id;
	if (argc != 2) {
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
	pthread_mutex_init(&mutx, NULL);
	serv_sock = socket(PF_INET, SOCK_STREAM, 0);
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family = AF_INET;
	serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_adr.sin_port = htons(atoi(argv[1]));
	if (bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
		error_handling("bind() error");
	if (listen(serv_sock, 5) == -1)
		error_handling("listen() error");
	while (1)
	{
		clnt_adr_sz = sizeof(clnt_adr);
		clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
		pthread_mutex_lock(&mutx);
		clnt_socks[clnt_cnt++] = clnt_sock;
		pthread_mutex_unlock(&mutx);
		pthread_create(&t_id, NULL, handle_clnt, (void*)&clnt_sock);
		pthread_detach(t_id);
		printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr));
	}
	close(serv_sock);
	return 0;
}
void* handle_clnt(void* arg)
{
	int clnt_sock = *((int*)arg);
	int str_len = 0, i;
		char msg[BUF_SIZE];
	while ((str_len = read(clnt_sock, msg, sizeof(msg))) != 0)
		send_msg(msg, str_len);
	pthread_mutex_lock(&mutx);
	for (i = 0; i < clnt_cnt; i++)
		// remove disconnected client
	{
	}
	if (clnt_sock == clnt_socks[i])
	{
		while (i++ < clnt_cnt - 1)
			clnt_socks[i] = clnt_socks[i + 1];
		break;
	}
	clnt_cnt--;
	pthread_mutex_unlock(&mutx);
	close(clnt_sock);
	return NULL;
}
void send_msg(char* msg, int len)
{
	int i;
	// send to all
	pthread_mutex_lock(&mutx);
	for (i = 0; i < clnt_cnt; i++)
		write(clnt_socks[i], msg, len);
	pthread_mutex_unlock(&mutx);
}
void error_handling(char* msg)
{
	fputs(msg, stderr);
	fputc('\n', stderr);
	exit(1);
}

2.客户端：

一个主线程即可

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>
#define BUF_SIZE 100
#define NAME_SIZE 20
void* send_msg(void* arg);
void* recv_msg(void* arg);
void error_handling(char* msg);
char name[NAME_SIZE] = "[DEFAULT]";
char msg[BUF_SIZE];
int main(int argc, char* argv[])
{
	int sock;
	struct sockaddr_in serv_addr;
	pthread_t snd_thread, rcv_thread;
	void* thread_return;
	if (argc != 4) {
		printf("Usage : %s <IP> <port> <name>\n", argv[0]);
		exit(1);
	}
	sprintf(name, "[%s]", argv[3]);
	sock = socket(PF_INET, SOCK_STREAM, 0);
	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
	serv_addr.sin_port = htons(atoi(argv[2]));
	if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1)
		error_handling("connect() error");
	pthread_create(&snd_thread, NULL, send_msg, (void*)&sock);
	pthread_create(&rcv_thread, NULL, recv_msg, (void*)&sock);
	pthread_join(snd_thread, &thread_return);
	pthread_join(rcv_thread, &thread_return);
	close(sock);
	return 0;
}
void* send_msg(void* arg)
{
	int sock = *((int*)arg);
	// send thread main
	char name_msg[NAME_SIZE + BUF_SIZE];
	while (1)
	{
	}
	fgets(msg, BUF_SIZE, stdin);
	if (!strcmp(msg, "q\n") || !strcmp(msg, "Q\n"))
	{
		close(sock);
		exit(0);
	}
	sprintf(name_msg, "%s %s", name, msg);
	write(sock, name_msg, strlen(name_msg));
	return NULL;
}
void* recv_msg(void* arg)
{
	int sock = *((int*)arg);
	// read thread main
	char name_msg[NAME_SIZE + BUF_SIZE];
	int str_len;
	while (1)
	{
		str_len = read(sock, name_msg, NAME_SIZE + BUF_SIZE - 1);
		if (str_len == -1)
			return (void*)-1;
		name_msg[str_len] = 0;
		fputs(name_msg, stdout);
	}
	return NULL;
}
void error_handling(char* msg)
{
	fputs(msg, stderr);
	fputc('\n', stderr);
	exit(1);
}

2.2 select 多路io复用实现

1. 原理及步骤

 文件描述符：

一开始默认是空的，当我们创建socket或者文件时，就会从3开始分配文件描述符给相应的socket或者文件

2.select 函数 与fd_set

select： 

#include<sys/select.h>#include <sys/time.h>
int select(int maxfd, fd_set*readset, fd_set* writeset, fd_set*exceptset, const struct
timeval * timeout);

成功时返回大于0的值，失败时返回-1。

  • maxtfd ：监视对象文件描述符数量
  • readset：用于检查可读性
  • writeset：用于检查可写性
  • exceptset：用于检查带外数据
  • timeout：一个指向timeval 结构的指针，用于决定select等待I/O的最长时间。如果为空将 一直等待。

fd_set结构体:

作用：用于表示一组文件描述符的集合，不要和文件描述符结构混淆

  • FD_ZERO（fdset*fdset）∶将 fdset 变量的所有位初始化为0。
  • FD_SET（int fd，fd set*fdset）∶在参数 fdset 指向的变量中注册文件描述符fd的信息。
  • FD_CLR（int fd，fdset*fdset）∶从参数 fdset 指向的变量中清除文件描述符fd的信息。
  • FD_ISSET（int fd，fd_set*fdset）∶若参数 fdset 指向的变量中包含文件描述符fd的信息，则 返回"真"。

3.select实现并发服务器 

主要步骤： 

1.由于serv_sock是最开始创建的，那么它一定是最大的文件描述符，且只创建了 serv_sock，我们将这个文件描述符添加到fd_map中（具有能够被select监听的资格，但这个监听和listen不是一个东西，如果相应文件描述符表示的sock有动作，那么select就会结束阻塞，开始后面的工作）：

	FD_ZERO(&reads);
	FD_SET(serv_sock, &reads);
	fd_max = serv_sock;

2. 进入循环，我们将当前的所有得到的文件描述符都放入进行监听

if ((fd_num = select(fd_max + 1, &cpy_reads, 0, 0, &timeout)) == -1)
			break;
if (fd_num == 0)
			continue;

 3.遍历到最大文件描述符，通过FD_SET来判断哪些文件描述符是被激活的（导致select不阻塞的），同时记得处理时，要把这个文件描述符clear掉

for (i = 0; i < fd_max + 1; i++)
		{
			if (FD_ISSET(i, &cpy_reads))
			{
				if (i == serv_sock)
				{
					// connection request!
					adr_sz = sizeof(clnt_adr);
					clnt_sock =
						accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
					FD_SET(clnt_sock, &reads);
					if (fd_max < clnt_sock)
						fd_max = clnt_sock;
					printf("connected client: %d \n", clnt_sock);
				}
				else
				{
					// read message!
					str_len = read(i, buf, BUF_SIZE);
					if (str_len == 0)
						// close request!
					{
						FD_CLR(i, &reads);
						close(i);
						printf("closed client: %d \n", i);
					}
					else
					{
					}
				}
				write(i, buf, str_len);
			}
		}

完整代码如下： 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/select.h>
#define BUF_SIZE 100
void error_handling(char* buf);
int main(int argc, char* argv[])
{
	int serv_sock, clnt_sock;
	struct sockaddr_in serv_adr, clnt_adr;
	struct timeval timeout;
	fd_set reads, cpy_reads;
	socklen_t adr_sz;
	int fd_max, str_len, fd_num, i;
	char buf[BUF_SIZE];
	if (argc != 2) {
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
	serv_sock = socket(PF_INET, SOCK_STREAM, 0);
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family = AF_INET;
	serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_adr.sin_port = htons(atoi(argv[1]));
	if (bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
		error_handling("bind() error");
	if (listen(serv_sock, 5) == -1)
		error_handling("listen() error");
	FD_ZERO(&reads);
	FD_SET(serv_sock, &reads);
	fd_max = serv_sock;
	while (1){
		cpy_reads = reads;
		timeout.tv_sec = 5;
		timeout.tv_usec = 5000;
		if ((fd_num = select(fd_max + 1, &cpy_reads, 0, 0, &timeout)) == -1)
			break;
		if (fd_num == 0)
			continue;
		for (i = 0; i < fd_max + 1; i++){
			if (FD_ISSET(i, &cpy_reads)){
				if (i == serv_sock){
					// connection request!
					adr_sz = sizeof(clnt_adr);
					clnt_sock =
						accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
					FD_SET(clnt_sock, &reads);
					if (fd_max < clnt_sock)
						fd_max = clnt_sock;
					printf("connected client: %d \n", clnt_sock);
				}
				else{
					// read message!
					str_len = read(i, buf, BUF_SIZE);
					// close request!
					if (str_len == 0){
						FD_CLR(i, &reads);
						close(i);
						printf("closed client: %d \n", i);
					}
					else{
						write(i, buf, str_len);
					}
				}
				
			}
		}
	}
	close(serv_sock);
	return 0;
}
void error_handling(char* buf)
{
	fputs(buf, stderr);
	fputc('\n', stderr);
	exit(1);
}

4.客户端

客户端代码和一般客户端无异： 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
void error_handling(char* message);
int main(int argc, char* argv[])
{
	int sock;
	char message[BUF_SIZE];
	int str_len;
	struct sockaddr_in serv_adr;
	if (argc != 3) {
		printf("Usage : %s <IP> <port>\n", argv[0]);
		exit(1);
	}
		sock = socket(PF_INET, SOCK_STREAM, 0);
	if (sock == -1)
		error_handling("socket() error");
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family = AF_INET;
	serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
	serv_adr.sin_port = htons(atoi(argv[2]));
		if (connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
			error_handling("connect() error!");
		else
			puts("Connected...........");
	while (1)
	{
		fputs("Input message(Q to quit): ", stdout);
		fgets(message, BUF_SIZE, stdin);
		if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
			break;
		write(sock, message, strlen(message));
		str_len = read(sock, message, BUF_SIZE - 1);
		message[str_len] = 0;
		printf("Message from server: %s", message);
	}
	close(sock);
	return 0;
}
void error_handling(char* message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

FreeRTOS任务创建过程详解

FreeRTOS任务创建过程详解

本篇文章及记录我在学习FreeRTOS中关于任务创建的详细过程的了解。希望我的分享能给你带来不一样的收获。 目录 一、任务创建的相关函数 二、任务初始化函数分析 三、任务堆栈初始化函数 四、添加任务到就绪列表 一、任务创建的相关函数 前面学了任务创建可以使用动态方法或…
阅读更多...
jQuery 基础、选择器和筛选器

jQuery 基础、选择器和筛选器

【一】JQuery基础 【1】什么时Jquery &#xff08;1&#xff09;定义 jQuery是一个流行的JavaScript库&#xff0c;旨在简化JavaScript编程和处理HTML文档的任务。它提供了一组易于使用的功能和方法&#xff0c;可以加快开发速度并提高跨浏览器兼容性。一款轻量级的JS框架 …
阅读更多...
LeetCode二叉搜索树的最近公共祖先

LeetCode二叉搜索树的最近公共祖先

题目描述 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为&#xff1a;“对于有根树 T 的两个结点 p、q&#xff0c;最近公共祖先表示为一个结点 x&#xff0c;满足 x 是 p、q 的祖先且 x 的深度尽可能大&#xff08;一个节点也…
阅读更多...
前后端分离Vue+nodejs校园论坛bbs系统x450z

前后端分离Vue+nodejs校园论坛bbs系统x450z

开发语言 node.js 框架&#xff1a;Express 前端:Vue.js 数据库&#xff1a;mysql 数据库工具&#xff1a;Navicat 开发软件&#xff1a;VScode本论文拟采用计算机技术设计并开发的论坛bbs系统&#xff0c;主要是为用户提供服务。使得用户可以在系统上查看帖子信息、签到积分等…
阅读更多...
数字化转型导师鹏：政府数字化转型政务服务类案例研究

数字化转型导师鹏：政府数字化转型政务服务类案例研究

政府数字化转型政务服务类案例研究 课程背景&#xff1a; 很多地方政府存在以下问题&#xff1a; 不清楚标杆省政府数字化转型的政务服务类成功案例 不清楚地级市政府数字化转型的政务服务类成功案例 不清楚县区级政府数字化转型的政务服务类成功案例 课程特色&#x…
阅读更多...
Apache POI技术-在Java中的基本使用

Apache POI技术-在Java中的基本使用

Apache POI技术-在Java中的基本使用 文章目录 Apache POI技术-在Java中的基本使用前言一、Apache POI是什么&#xff1f;1.Apache POI简介&#xff1a;2.Apache POI主要包括的模块&#xff1a;3.Apache POI 的应用场景&#xff1a;报表生成&#xff1a;数据导入导出&#xff1a…
阅读更多...
Python爬虫进阶：爬取在线电视剧信息与高级检索

Python爬虫进阶：爬取在线电视剧信息与高级检索

简介&#xff1a; 本文将向你展示如何使用Python创建一个能够爬取在线电视剧信息的爬虫&#xff0c;并介绍如何实现更高级的检索功能。我们将使用requests和BeautifulSoup库来爬取数据&#xff0c;并使用pandas库来处理和存储检索结果。 目录 一、爬取在线电视剧信息 …
阅读更多...
[ai笔记13] 大模型架构对比盘点：Encoder-Only、Decoder-Only、Encoder-Decoder

[ai笔记13] 大模型架构对比盘点：Encoder-Only、Decoder-Only、Encoder-Decoder

欢迎来到文思源想的ai空间&#xff0c;这是技术老兵重学ai以及成长思考的第13篇分享&#xff01; 最近看完《这就是chatgpt》对于大语言模型的三种架构演进图印象颇深&#xff0c;今日就专题盘点一下三种大模型架构理论&#xff0c;同时做一个简单对比。 1 Encoder-Only架构 …
阅读更多...
day4：对话框与事件

day4：对话框与事件

使用qt搭建一个简易的闹钟系统 #include "second.h" #include "ui_second.h"second::second(QWidget *parent) :QWidget(parent),ui(new Ui::second) {ui->setupUi(this);this->setWindowFlag(Qt::FramelessWindowHint);this->setAttribute(Qt::…
阅读更多...
基于yolov5的电瓶车和自行车检测系统，可进行图像目标检测，也可进行视屏和摄像检测（pytorch框架）【python源码+UI界面+功能源码详解】

基于yolov5的电瓶车和自行车检测系统，可进行图像目标检测，也可进行视屏和摄像检测（pytorch框架）【python源码+UI界面+功能源码详解】

功能演示&#xff1a; 基于yolov5的电瓶车和自行车检测系统_哔哩哔哩_bilibili &#xff08;一&#xff09;简介 基于yolov5的电瓶车和自行车检测系统是在pytorch框架下实现的&#xff0c;这是一个完整的项目&#xff0c;包括代码&#xff0c;数据集&#xff0c;训练好的模型…
阅读更多...
【Linux】部署前后端分离项目---(Nginx自启，负载均衡）

【Linux】部署前后端分离项目---(Nginx自启，负载均衡）

目录 前言 一 Nginx&#xff08;自启动&#xff09; 2.1 Nginx的安装 2.2 设置自启动Nginx 二 Nginx负载均衡tomcat 2.1 准备两个tomcat 2.1.1 复制tomcat 2.1.2 修改server.xml文件 2.1.3 开放端口 2.2 Nginx配置 2.2.1 修改nginx.conf文件 2.2.2 重启Nginx服务 2…
阅读更多...
代码随想录刷题笔记 DAY 32 | K 次取反后最大化的数组和 No.1005 | 加油站 No.134 | 分发糖果 No.135

代码随想录刷题笔记 DAY 32 | K 次取反后最大化的数组和 No.1005 | 加油站 No.134 | 分发糖果 No.135

文章目录 Day 3201. K 次取反后最大化的数组和&#xff08;No. 1005&#xff09;1.1 题目1.2 笔记1.3 代码 02. 加油站&#xff08;No. 134&#xff09;2.1 题目2.2 笔记2.3 代码 03. 分发糖果&#xff08;No. 135&#xff09;3.1 题目3.2 笔记3.3 代码 Day 32 01. K 次取反后…
阅读更多...
测试C#使用PuppeteerSharp将网页生成PDF文件

测试C#使用PuppeteerSharp将网页生成PDF文件

微信公众号“DotNet开发跳槽”、“dotNET跨平台”、“DotNet”发布了几篇将网页生成图片或pdf文件的文章&#xff08;参考文献2-5&#xff09;&#xff0c;其中介绍了使用puppeteer-sharp、Select.HtmlToPdf、iTextSharp等多种方式实现html转图片或pdf&#xff0c;正好最近有类…
阅读更多...
探秘SuperCLUE-Safety：为中文大模型打造的多轮对抗安全新框架

探秘SuperCLUE-Safety：为中文大模型打造的多轮对抗安全新框架

探秘SuperCLUE-Safety&#xff1a;为中文大模型打造的多轮对抗安全新框架 进入2023年以来&#xff0c;ChatGPT的成功带动了国内大模型的快速发展&#xff0c;从通用大模型、垂直领域大模型到Agent智能体等多领域的发展。但是生成式大模型生成内容具有一定的不可控性&#xff0…
阅读更多...
本地部署ChatGPT

本地部署ChatGPT

发布一下我之前做的一个本地大模型部署,不需要API key,但要有自己的账号 利用Docker 的Pandora做本地ChatGPT模型部署 先下载安装Docker,设置好运行如下 会要求升级核心,cmd运行如下命令就OK 安装Pandora 再管理员cmd中输入如下命令拉取Pandora镜像 docker pull pengzhi…
阅读更多...
SpringBoot -【BeanFactory】基础使用及应用场景

SpringBoot -【BeanFactory】基础使用及应用场景

1.介绍 在 Spring 框架中&#xff0c;BeanFactory 是 Spring IoC 容器的核心接口&#xff0c;负责管理 bean 的创建、配置和装配。它是 Spring IoC 容器的基础。BeanFactory 接口定义了一系列方法&#xff0c;用于管理和访问容器中的 bean 对象。 BeanFactoryAware 用于在 Sp…
阅读更多...
AD24-Gerber生产文件输出及整理

AD24-Gerber生产文件输出及整理

一、Gerber生产文件输出 1、先进行规则检查 2、Gerber Files输出 3、钻孔文件 4、IPC网表 5、坐标文件 二、Gerber Flies文件整理 1、CAM 2、SMT 3、ASM 4、PRJ 5、DXF
阅读更多...
Django定时任务之django_apscheduler使用

Django定时任务之django_apscheduler使用

Django定时任务之django_apscheduler使用 今天在写一个任务需求时需要用到定时任务来做一部分数据处理与优化&#xff0c;于是在了解完现有方法&#xff0c;结合自己需求决定使用django_apscheduler&#xff0c;记录一下过程&#xff0c;有几篇值得参考的文章放在结尾&#xf…
阅读更多...
8.网络游戏逆向分析与漏洞攻防-游戏网络架构逆向分析-游戏底层功能对接类GameProc的实现

8.网络游戏逆向分析与漏洞攻防-游戏网络架构逆向分析-游戏底层功能对接类GameProc的实现

内容参考于&#xff1a;易道云信息技术研究院VIP课 上一个内容&#xff1a;通过逆向分析确定游戏明文接收数据过程 码云地址&#xff08;master 分支&#xff09;&#xff1a;https://gitee.com/dye_your_fingers/titan 码云版本号&#xff1a;bcf7559184863febdcad819e48aaa…
阅读更多...
应用配置管理

应用配置管理

一、Pod 配置管理 可变配置用 ConfigMap&#xff1b; 敏感信息用 Secret&#xff1b; 身份认证用 ServiceAccount 这几个独立的资源来实现的&#xff1b; 资源配置用 Resources&#xff1b; 安全管控用 SecurityContext&#xff1b; 前置校验用 InitContainers 这几个在 …
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站