服务器模型：循环服务器（TCP）和并发服务器（TCP）

已于 2022-09-15 22:39:00 修改
阅读量1.7k 收藏 10
点赞数 2
文章标签： 服务器 tcp/ip 网络 网络协议
于 2022-09-15 20:32:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57723364/article/details/126877612
版权

        网络通信中，服务器端会面对需要处理多个客户端的情况，由于客户端的请求不定时，可能同时请求；总体来说，服务器端一般采用循环服务器模型和并发服务器模型来处理。

循环服务器模型：服务器端依次处理每个客户端，直到当前客户端所有请求处理完成，再处理下一个客户端。

并发服务器模型：在服务器端采用多任务机制（多进程或者多线程），分别为每一个客户端创造一个任务来处理。

两者对比
循环服务器模型并发服务器模型
优点简单服务器并发处理能力强，客户端不用等待时间过长
缺点单一处理，容易造成其他客户端等待时间过长需要避免僵死模式

  TCP循环服务器模型：（工作流程）/（特点分析）

  1. 服务器端从连接请求队列中提取请求，建立连接并返回新的已经连接套接字；
  2. 服务器端通过已经连接的套接字循环接受数据，处理并发送给客户端直到客户端关闭；
  3. 服务器关闭已连接套接字，返回步骤（1）处理下一个客户端；
  4. -------------------------------------------------------------------------------------------------------------------
  5. 服务器端采用循环嵌套来实现：外层循环依次提取客户端的请求队列并建立TCP连接，内层循环接受处理连接客户端的所有数据，直到客户端关闭；
  6. 如果当前客户端没有处理结束，其他客户端必须一直等待；

 流程：

socket(...); 
bind(...); 
listen(...);
while(1) 
{ 
    accept(...); 
    if(fork() == 0) 
    { 
        while(1) 
        { 
            recv(...); 
            process(...); 
            send(...); 
        }
            close(...); 
            exit(...); 
    }    
    close(...); 
}

 代码实现：

TCP循环服务器：

#include <stdio.h>
#include "net.h"
#include <string.h>
//编写一子函数,监听socket对象
//参数1：IP地址  char * ip
//参数2：端口号  int port
//返回值：失败返回-1,成功返回socket对象
int tcp_server(char * ip,int port);
int tcp_server(char * ip,int port)
{

	//1.创建Tcp套接字
	//2.绑定自己的IP地址和端口号
	//3.设置监听是否有人连接
	//创建并打开套接字
	int sockFd = socket(AF_INET,SOCK_STREAM,0);
	if(sockFd < 0)
	{
		perror("socket error");
		return -1;
	}
	//绑定服务器地址信息
	struct sockaddr_in servAddr = {0};
	servAddr.sin_family = AF_INET;
	servAddr.sin_port = htons(port);
	servAddr.sin_addr.s_addr = inet_addr(ip);
	int ret = bind(sockFd,(struct sockaddr *)&servAddr,sizeof(servAddr));
	if(ret < 0)
	{
		perror("bind error");
		return -1;
	}
	printf("bind OK\n");
	//创建监听队列
	ret = listen(sockFd,5);
	if(ret < 0)
	{
		perror("listen error");
		close(sockFd);
		return -1;
	}
	printf("listen OK\n");
	return sockFd;
}

//编写一子函数，实现客户端和服务器端的通信
//参数：连接好的socket对象
//返回值：通信结束返回-1，继续返回0
int tcp_com(int sockFd);
int tcp_com(int sockFd)
{
	char buf[N]={'\0'};
	char cmd[N]={'\0'};
	char filename[N]={'\0'};
	//接受客户端发过来的消息
	recv(sockFd,buf,sizeof(buf),0); //第一次接受"hello"
	printf("buf=%s\n",buf);
	if(strncmp(buf,"quit",4)==0)
	{
		printf("通信结束");
		return -1;

	}
	parseStr(buf,cmd,filename);	
	printf("cmd=%s\n",cmd);
	printf("filename=%s\n",filename);

	if(strncmp(cmd,"put",3)==0)
	{
		//接受文件(下载文件 download)
		download(sockFd,filename);
	}else if(strncmp(cmd,"get",3)==0)
	{
		//发送文件(上传文件 upload)
	}else
	{
		printf("指令有误\n");
	}

	return 0;
}

int main(int argc,char * argv[])
{
	if(argc!=3)
	{
		printf("input appname ip port\n");
		return -1;
	}
	//1.监听socket对象

	int tcp_socket=tcp_server(argv[1],atoi(argv[2]));
	//2.接受连接
	struct sockaddr_in client;
	int len=sizeof(client);

	while(1)
	{
		int newfd=accept(tcp_socket,(struct sockaddr *)&client,&len);
		if(newfd<0)
		{
			perror("accept error");
			return -1;
		}
		printf("accept ok\n");

		printf("client ip=%s  port=%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));

		while(1)
		{
			//3.接受/发送消息
			int n=tcp_com(newfd);

			//客户端和服务器端进行通信
			if(n<0){
				//4.关闭套接字
				close(newfd);
				break;
			}
		}
	}
	close(tcp_socket);
}

 头文件：

#ifndef _NET_H
#define _NET_H
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#define N 20
int parseStr(char *buf,char * cmd,char * filename);
int download(int sockfd,char * filename);
#endif

 

 对应客户端：

#ifndef _NET_H
#define _NET_H
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#define N 20
int parseStr(char *buf,char * cmd,char * filename);
int upload(int sockfd,char * filename);
#endif


#include <stdio.h>
#include "net.h"
#include <string.h>
//编写一子函数，连接服务器
//参数1：IP地址ecv(sockFd,buf,sizeof(buf),0);
//参数2：端口号
//返回值：连接成功返回连接好的socket对象,失败返回-1
int tcp_connect(char * ip,int port);
int tcp_connect(char * ip,int port)
{
	//1.创建Tcp套接字
	//2.设置对方的IP地址和端口号
	//3.请求连接


	//创建并打开套接字
	int sockFd = socket(AF_INET,SOCK_STREAM,0);
	if(sockFd < 0)
	{
		perror("socket error");
		return -1;
	}
	printf("socket OK\n");
	//连接服务器
	struct sockaddr_in servAddr = {0};
	servAddr.sin_family = AF_INET;
	servAddr.sin_port = htons(port);
	servAddr.sin_addr.s_addr = inet_addr(ip);
	int ret = connect(sockFd,(struct sockaddr *)&servAddr,sizeof(servAddr));
	if(ret < 0)
	{
		close(sockFd);
		return -1;
	}
	printf("connect OK\n");
	return  sockFd;
}


//编写一子函数，实现客户端和服务端的通信
//参数:连接好的socket对象
//返回值：通信结束返回-1，继续返回0
int tcp_com(int sockFd);
int tcp_com(int sockFd)
{
	printf("请输入指令");
	char buf[N]={'\0'};
	char cmd[N]={'\0'};
	char filename[N]={'\0'};

	fgets(buf,sizeof(buf),stdin);
	send(sockFd,buf,strlen(buf),0);
	parseStr(buf,cmd,filename);
	printf("cmd==%s\n",cmd);
	printf("filename=%s\n",filename);

	if(strncmp(cmd,"put",3)==0)
	{
		//上传文件upload()
		upload(sockFd,filename);

	}else if(strncmp(cmd,"get",3)==0)
	{
		//下载文件download()
	}else if(strncmp(cmd,"quit",4)==0)
	{
		printf("通信结束\n");
		return -1;
	}else 
	{
		printf("指令有误\n");
	}



	return 0;
}

int main(int argc,char * argv[])
{
	if(argc!=3)
	{
		printf("input appname ip  port\n");
		return -1;
	}
	//1.请求连接服务器  //atoi()将字符串转换成整数
	//		    atof()将字符串转换成float
	int tcp_socket=tcp_connect(argv[1],atoi(argv[2]));
	//2.发送/接受消息
	while(1){
		//客户端和服务端之间的通信
		int n=tcp_com(tcp_socket);
		//3.关闭套接字
		if(n<0){
			close(tcp_socket);
			break;
		}
	}
	//
	//
}

TCP并发服务器模型：（工作流程）/（特点分析）

  1. 服务器端父进程从连接请求队列中提取请求，建立连接并返回新的已创建套接字；
  2. 服务器端父进程创建子进程为客户端服务，客户端关闭连接时，子进程结束；
  3. 服务器端父进程关闭已连接套接字，返回步骤（1）；
  4. --------------------------------------------------------------------------------------------------------
  5. 服务器端父进程一旦接收到客户端的连接请求，便建立好连接并创建新的子进程。这意味着每个客广端在服务器端有一个专门的子进程为其服务。
  6. 服务器端的多个子进程同时运行 （宏观上），处理多个容户端。
  7. 服务器端的父进程不具体处理每个客户端的数据请求。

 1.多进程----流程：

socket(...)
bind(...)
listen(...)
while(1)
{
    accept(...)
    if(fork(...)==0)
    {
        process(...);
        close(...);
        exit(...);
    }
    close(...);
}

 代码实现：

头文件：

#ifndef _NET_H
#define _NET_H
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <signal.h>
#define N 20
int parseStr(char *buf,char * cmd,char * filename);
int download(int sockfd,char * filename);
#endif

 TCP多进程并发服务器：

#include <stdio.h>
#include "net.h"
#include <string.h>
//编写一子函数,监听socket对象
//参数1：IP地址  char * ip
//参数2：端口号  int port
//返回值：失败返回-1,成功返回socket对象
int tcp_server(char * ip,int port);
int tcp_server(char * ip,int port)
{

	//1.创建Tcp套接字
	//2.绑定自己的IP地址和端口号
	//3.设置监听是否有人连接
	//创建并打开套接字
	int sockFd = socket(AF_INET,SOCK_STREAM,0);
	if(sockFd < 0)
	{
		perror("socket error");
		return -1;
	}
	//绑定服务器地址信息
	struct sockaddr_in servAddr = {0};
	servAddr.sin_family = AF_INET;
	servAddr.sin_port = htons(port);
	servAddr.sin_addr.s_addr = inet_addr(ip);
	int ret = bind(sockFd,(struct sockaddr *)&servAddr,sizeof(servAddr));
	if(ret < 0)
	{
		perror("bind error");
		return -1;
	}
	printf("bind OK\n");
	//创建监听队列
	ret = listen(sockFd,5);
	if(ret < 0)
	{
		perror("listen error");
		close(sockFd);
		return -1;
	}
	printf("listen OK\n");
	return sockFd;
}

//编写一子函数，实现客户端和服务器端的通信
//参数：连接好的socket对象
//返回值：通信结束返回-1，继续返回0
int tcp_com(int sockFd);
int tcp_com(int sockFd)
{
	char buf[N]={'\0'};
	char cmd[N]={'\0'};
	char filename[N]={'\0'};
	//接受客户端发过来的消息
	recv(sockFd,buf,sizeof(buf),0); //第一次接受"hello"
	printf("buf=%s\n",buf);
	if(strncmp(buf,"quit",4)==0)
	{
		printf("通信结束");
		return -1;

	}
	parseStr(buf,cmd,filename);	
	printf("cmd=%s\n",cmd);
	printf("filename=%s\n",filename);

	if(strncmp(cmd,"put",3)==0)
	{
		//接受文件(下载文件 download)
		download(sockFd,filename);
	}else if(strncmp(cmd,"get",3)==0)
	{
		//发送文件(上传文件 upload)
	}else
	{
		printf("指令有误\n");
	}

	return 0;
}

void handler(int sig)
{
	printf("子进程发生改变\n");
	while(waitpid(-1,NULL,WNOHANG)>0);
}

int main(int argc,char * argv[])
{
	if(argc!=3)
	{
		printf("input appname ip port\n");
		return -1;
	}
	signal(SIGCHLD,handler); //安装信号
	//1.监听socket对象

	int tcp_socket=tcp_server(argv[1],atoi(argv[2]));
	//2.接受连接
	struct sockaddr_in client;
	int len=sizeof(client);
	pid_t pid=0;
	while(1)
	{
		int newfd=accept(tcp_socket,(struct sockaddr *)&client,&len);
		if(newfd<0)
		{
			perror("accept error");
			return -1;
		}
		printf("accept ok\n");
		printf("client ip=%s  port=%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
		//创建子进程和客户端进行通信
		pid=fork();
		if(pid<0)
		{
			perror("fork error");
			return -1;
		}else if(pid==0) //子进程
		{
			while(1)  
			{
				//3.接受/发送消息
				int n=tcp_com(newfd);
				//客户端和服务器端进行通信
				if(n<0){
					//4.关闭套接字
					close(newfd);
					break;
				}
			}
			exit(0);//子进程提出
		}
		close(newfd);
	}
	close(tcp_socket);
}

2.多线程----流程 ：

socket(...)
bind(...)
listen(...)
while(1)
{
    accept(...)
    if(pthread_create(...)== 0)
    {
        process(...);
        close(...);
        exit(...);
    }
    close(...);
}

代码实现：

头文件：

#ifndef _NET_H
#define _NET_H
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#define N 20
int parseStr(char *buf,char * cmd,char * filename);
int download(int sockfd,char * filename);
#endif

 TCP多线程服务器端：

#include <stdio.h>
#include "net.h"
#include <string.h>
//编写一子函数,监听socket对象
//参数1：IP地址  char * ip
//参数2：端口号  int port
//返回值：失败返回-1,成功返回socket对象
int tcp_server(char * ip,int port);
int tcp_server(char * ip,int port)
{

	//1.创建Tcp套接字
	//2.绑定自己的IP地址和端口号
	//3.设置监听是否有人连接
	//创建并打开套接字
	int sockFd = socket(AF_INET,SOCK_STREAM,0);
	if(sockFd < 0)
	{
		perror("socket error");
		return -1;
	}
	//绑定服务器地址信息
	struct sockaddr_in servAddr = {0};
	servAddr.sin_family = AF_INET;
	servAddr.sin_port = htons(port);
	servAddr.sin_addr.s_addr = inet_addr(ip);
	int ret = bind(sockFd,(struct sockaddr *)&servAddr,sizeof(servAddr));
	if(ret < 0)
	{
		perror("bind error");
		return -1;
	}
	printf("bind OK\n");
	//创建监听队列
	ret = listen(sockFd,5);
	if(ret < 0)
	{
		perror("listen error");
		close(sockFd);
		return -1;
	}
	printf("listen OK\n");
	return sockFd;
}

//编写一子函数，实现客户端和服务器端的通信
//参数：连接好的socket对象
//返回值：通信结束返回-1，继续返回0
int tcp_com(int sockFd);
int tcp_com(int sockFd)
{
	char buf[N]={'\0'};
	char cmd[N]={'\0'};
	char filename[N]={'\0'};
	//接受客户端发过来的消息
	recv(sockFd,buf,sizeof(buf),0); //第一次接受"hello"
	printf("buf=%s\n",buf);
	if(strncmp(buf,"quit",4)==0)
	{
		printf("通信结束");
		return -1;

	}
	parseStr(buf,cmd,filename);	
	printf("cmd=%s\n",cmd);
	printf("filename=%s\n",filename);

	if(strncmp(cmd,"put",3)==0)
	{
		//接受文件(下载文件 download)
		download(sockFd,filename);
	}else if(strncmp(cmd,"get",3)==0)
	{
		//发送文件(上传文件 upload)
	}else
	{
		printf("指令有误\n");
	}

	return 0;
}


//创建子线程
void * thread(void *arg)
{
	int * pfd=(int *)arg; //处理主线程给子线程传过来的值
	int newfd=*pfd;
	//参数:需要连接好的socket对象
		while(1)
		{
			//3.接受/发送消息
			int n=tcp_com(newfd);

			//客户端和服务器端进行通信
			if(n<0){
				//4.关闭套接字
				close(newfd);
				pthread_exit(0);//线程的退出
				break;
			}
		}

}
int main(int argc,char * argv[])
{
	if(argc!=3)
	{
		printf("input appname ip port\n");
		return -1;
	}
	//1.监听socket对象

	int tcp_socket=tcp_server(argv[1],atoi(argv[2]));
	//2.接受连接
	struct sockaddr_in client;
	int len=sizeof(client);
	
	pthread_t pid;
	while(1)
	{
		int newfd=accept(tcp_socket,(struct sockaddr *)&client,&len);
		if(newfd<0)
		{
			perror("accept error");
			return -1;
		}
		printf("accept ok\n");
		printf("client ip=%s  port=%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
		//创建子线程实现和客户端的通信
		//第四个参数：主线程给子线程传值
		pthread_create(&pid,NULL,thread,&newfd);

	}
	close(tcp_socket);
}

 对应客户端：

头文件：

#ifndef _NET_H
#define _NET_H
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#define N 20
int parseStr(char *buf,char * cmd,char * filename);
int upload(int sockfd,char * filename);
#endif


#include <stdio.h>
#include "net.h"
#include <string.h>
//编写一子函数，连接服务器
//参数1：IP地址ecv(sockFd,buf,sizeof(buf),0);
//参数2：端口号
//返回值：连接成功返回连接好的socket对象,失败返回-1
int tcp_connect(char * ip,int port);
int tcp_connect(char * ip,int port)
{
	//1.创建Tcp套接字
	//2.设置对方的IP地址和端口号
	//3.请求连接


	//创建并打开套接字
	int sockFd = socket(AF_INET,SOCK_STREAM,0);
	if(sockFd < 0)
	{
		perror("socket error");
		return -1;
	}
	printf("socket OK\n");
	//连接服务器
	struct sockaddr_in servAddr = {0};
	servAddr.sin_family = AF_INET;
	servAddr.sin_port = htons(port);
	servAddr.sin_addr.s_addr = inet_addr(ip);
	int ret = connect(sockFd,(struct sockaddr *)&servAddr,sizeof(servAddr));
	if(ret < 0)
	{
		close(sockFd);
		return -1;
	}
	printf("connect OK\n");
	return  sockFd;
}


//编写一子函数，实现客户端和服务端的通信
//参数:连接好的socket对象
//返回值：通信结束返回-1，继续返回0
int tcp_com(int sockFd);
int tcp_com(int sockFd)
{
	printf("请输入指令");
	char buf[N]={'\0'};
	char cmd[N]={'\0'};
	char filename[N]={'\0'};

	fgets(buf,sizeof(buf),stdin);
	send(sockFd,buf,strlen(buf),0);
	parseStr(buf,cmd,filename);
	printf("cmd==%s\n",cmd);
	printf("filename=%s\n",filename);

	if(strncmp(cmd,"put",3)==0)
	{
		//上传文件upload()
		upload(sockFd,filename);

	}else if(strncmp(cmd,"get",3)==0)
	{
		//下载文件download()
	}else if(strncmp(cmd,"quit",4)==0)
	{
		printf("通信结束\n");
		return -1;
	}else 
	{
		printf("指令有误\n");
	}



	return 0;
}

int main(int argc,char * argv[])
{
	if(argc!=3)
	{
		printf("input appname ip  port\n");
		return -1;
	}
	//1.请求连接服务器  //atoi()将字符串转换成整数
	//		    atof()将字符串转换成float
	int tcp_socket=tcp_connect(argv[1],atoi(argv[2]));
	//2.发送/接受消息
	while(1){
		//客户端和服务端之间的通信
		int n=tcp_com(tcp_socket);
		//3.关闭套接字
		if(n<0){
			close(tcp_socket);
			break;
		}
	}
	//
	//
}

 （注：部分段落参考自《嵌入式-应用程序设计综合教程微课版》）

......……_
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Linux下几种并发服务器的实现模式(详解)
09-15
在Linux操作系统中，实现并发服务器有多种方法，每种方式都有其特定的优缺点，适用于不同的场景和需求。下面将详细解析这些实现模式。 1. 单线程或单进程服务器： 这种模式是最简单的实现，服务器在接收到连接请求...
Java编程实现多线程TCP服务器完整实例
08-28
总结来说，Java编程实现多线程TCP服务器的关键在于正确地使用 `Socket` 和 `ServerSocket` 类，以及有效地管理并发连接，如通过线程池或异步I/O来优化性能。理解这些基础概念和技术，对于开发高效的网络应用程序至关...
多进程并发服务器与多线程并发服务器
qq_48054241的博客
04-23 243
【代码】多进程并发服务器与多线程并发服务器。
【网络编程】高性能并发服务器源码剖析
weixin_73951752的博客
04-14 2585
hello！大家好呀！欢迎大家来到我的网络编程系列之洪水网络攻击，在这篇文章中，希望这篇文章能对你有所帮助，大家要是觉得我写的不错的话，那就点点免费的小爱心吧！
网络编程day4——TCP循环服务器模型与并发服务器模型
最新发布
weixin_54481049的博客
05-07 1470
只有在当前客户的所有请求都完成后，服务器才能处理下一个客户的连接/服务请求。关键是在某个客户端产生通信套接字后，在recv/send部分用一个while循环，直到此客户端完全结束通讯任务，才会产生新的通信套接字继续通信。并发服务器的设计思想是服务器接受客户端的连接请求后创建子进程来为客户端服务。： 大规模的 Web 服务器（如 Apache）、数据库服务器、在线游戏服务器等，需要处理大量并发连接的应用。TCP服务器接受一个客户端的连接后开始处理，完成了客户的所有请求后断开连接。
服务器并发处理几种模式：基本服务模式、多进程、多线程、I/O多路复用
David_jiang
03-22 695
不同于多进程或多线程模式下的阻塞式I/O 模型，I/O 复用方式只会使进程受阻于select 或epoll 的函数调用，等待多个套接字中的任一个就绪，避免在实际的I/O 数据读写时发生阻塞。对于已连接的事件，创建一个新的线程来进行实际数据的IO 过程，线程与客户连接一一对应，依据多核CPU 实现并发，同时服务于多个客户，通常以thread-per-connection 简称之。在多进程服务器中，父进程会持续进行端口的监听工作，每当客户端的连接请求到来，立刻fork 对应的新子进程进行处理。
TCP服务器模型
m0_72647108的博客
08-03 470
TCP通信
基于TCP客户端和服务器的I/O多路复用
zjq_smile的博客
12-05 1730
一、基于TCP/IP协议的基本循环服务器 tcp_server.c [cpp] view plain copy   #include    #include    #include       #include    #include    #include    #include       #define PORT 33
Windows下的TCP回显多线程服务器.pdf
10-27
本文将深入探讨Windows下基于TCP的阻塞模型的并发回显服务器的构建，以及与Unix Socket API的比较。 一、TCP回显服务器原理 TCP回显服务器是一种简单的网络服务，它接收客户端发送的数据，然后原样返回。这种...
Linux源码-TCP网络服务器的实现
08-26
在网络服务器编程中，常用的服务器模型有两种：循环服务和并发服务。循环服务是一种典型的服务器模型，在这种模型中，服务器处理完一个客户端的请求后，才会处理下一个客户端的请求。如果不使用多进程或多线程技术，...
第讲-服务器软件设计的算法和问题优秀文档.ppt
11-14
在服务器的实现中，有循环服务器和并发服务器两种模式。循环服务器每次只处理一个请求，简单易实现，但效率较低。并发服务器则可以同时处理多个请求，通常通过多线程或多进程实现，性能较好但设计复杂。 在编程过程...
TCP简单循环服务器demo
05-05
自己写的简单的TCP循环服务器，简单易学，初学者可以看看
TCP并发服务器、循环服务器、客户端 UDP服务器、客户端
12-18
最简单的TCP服务器客户端代码、UDP服务器客户端代码 TCP服务器中并发服务器和循环服务器都有 直接GCC编译即可
tcp并发服务器
10-22
tcp并发服务器
go tcp编程案例-服务端循环接收客户端消息2
qq_27751235的博客
01-24 376
【代码】go tcp编程案例-服务端循环接收客户端消息2。
05_TCP并发服务器
buhuidage的博客
11-19 1175
05_TCP并发服务器
Linux网络编程之TCP编程
qq_54402650的博客
09-17 2339
socket网络编程 ;TCP提供面向连接的，一对一的可靠传输的协议;UDP提供不可靠，无连接的传输协议,实现TCP多进程和多线程的并发服务器，冲冲冲！
网络编程知识三之TCP协议与常见服务器模型
Danny_llp的博客
05-08 1355
一.tcp(传输控制协议)协议简介 协议： 双方约定好的数据包格式，类似于快递公司让我们要在固定位置填收货人地址和电话号码。 特点： 1>面向连接 1)三次握手 2)四次挥手 2>保证数据包的可靠性 数据无丢失,数据包无错误, 数据包无失序,数据无重复达到 TCP协议使用的产品: 发送邮件,数据下载，QQ登录 … 3>TCP创建流程图 注意: 1. 监听套接字(套接字被设置成监听模式，专门接受客户端连接请求) 2. 每一步流程的作用 4>TCP数据传输原理 注意: 1. 客户端
TCP的高并发服务器模型
pingxiaozhao的博客
11-04 1003
【1】单客户端单进程，统一accept() 原型介绍： 此并发服务器模型并不预先分叉进程，而是主进程统一处理客户端的连接，当客户端的请求到达时，才临时fork()进程，由子进程处理客户端请求。 利用socket()函数建立套接字，调用bind()函数绑定地址，调用listen()函数来监听队列长度，然后进入主处理过程，等待客户端连接的到来。当客户端连接到来时，服务器的accept()函数成功返回...
用C语言写一个高并发模型的服务器的代码
09-19
### 回答1： 高并发模型的服务器的C语言代码如下：#include ...总的来说，实现高并发模型服务器的代码需要结合具体的需求和实际情况来选择合适的方式，并且需要考虑到线程或者进程之间的同步和通信问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

......……_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值