TCP网络服务器模型

最新推荐文章于 2025-05-22 14:26:09 发布
原创 最新推荐文章于 2025-05-22 14:26:09 发布 · 632 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#服务器 #TCP服务器模型 #循环服务器 #并发服务器 #并发

本文介绍了两种常见的TCP服务器模型：循环服务器和并发服务器。循环服务器适用于客户端连接时间较短的情况；并发服务器包括多进程、多线程及IO多路复用等实现方式，适合客户端数量较多且连接时间较长的应用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

服务器模型

1、循环服务器
实现流程：
1）、服务器端从连接请求队列中提取请求，建立连接并返回已连接的套接字。
2）、服务器端通过以连接的套接字循环接收数据，处理并发给客户端，直到客户端关闭连接。
3）、服务器端关闭已连接的套接字，返回步骤 1）。


特点：
    1.服务器采用循环嵌套实现，外层循环一次提取每个客户端的链接请求，建立TCP链接。内层循环接收连接并处理当前客户端的所有数据，知道客户端关闭连接。
      如果当前客户端没有处理结束，其他客户端必须一直等待。
    2.采用这种循环服务器端无法实现对多个客户端服务。适应于客户端连接时间短的情况。 
    3.同一时刻只能处理一个客户端的请求，一般很少使用


服务器代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>

int main()
{
    //定义结构体变量，作为bind函数的参数
    struct sockaddr_in servAddr;
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = PF_INET;
    servAddr.sin_port = htons(8888);
    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    //创建套接字
    //返回值为新创建的socket的文件描述符，失败-1
    int servFd = socket(PF_INET, SOCK_STREAM, 0);
    if(servFd < 0)
    {
        perror("socket error!");
        return -1;
    }
    printf("socket ok!\n");
    //绑定地址信息
    int ret = bind(servFd, (struct sockaddr *)&servAddr, sizeof(servAddr));
    if(ret < 0)
    {
        perror("bind error!");
        close(servFd);
        return -1;
    }
    printf("bind ok!\n");
    //创建监听队列
    ret = listen(servFd, 10);
    if(ret < 0)
    {
        perror("listen error!");
        close(servFd);
        return -1;
    }
    printf("listening.....\n");

    while(1)
    {
        //接收连接请求
        int connFd = accept(servFd, NULL, NULL);
        if(connFd < 0)
        {
            perror("accept error!");
            close(servFd);
            return -1;
        }
        printf("accept ok!\n");

        char buf[1024] = {0};
        //接收消息
        ret = recv(connFd, buf, sizeof(buf), 0);
        if(ret < 0)
        {
            perror("recv error!");
            close(servFd);
            close(connFd);
            return -1;
        }
        printf("recv from client: %s\n", buf);

        strcat(buf, "+++");
        send(connFd, buf, sizeof(buf), 0);
        //关闭套接字
        close(connFd);
        sleep(10);
    }
    close(servFd);
    return 0;
}









































































































客户端代码：
#include<stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>


int main()
{
    //定义结构体变量，该变量保存的服务器的地址信息,作为connect的参数
    struct sockaddr_in servAddr;
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = PF_INET;
    servAddr.sin_port = htons(8888);
    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    //创建套接字
    int cliFd = socket(PF_INET, SOCK_STREAM, 0);
    if(cliFd < 0)
    {
        perror("socket error!");
        return -1;
    }
    printf("socket ok!\n");
    //发起连接请求
    int ret = connect(cliFd, (struct sockaddr *)&servAddr, sizeof(servAddr));
    if(ret < 0)
    {
        perror("connect error!");
        close(cliFd);
        return -1;
    }
    printf("connect ok!\n");
    char buf[1024] = "hello world";
    //发送消息
    ret = send(cliFd, buf, sizeof(buf), 0);
    if(ret < 0)
    {
        perror("send error!");


        close(cliFd);
        return -1;
    }
    printf("send ok!\n");

    memset(buf, 0, sizeof(buf));
    recv(cliFd, buf, sizeof(buf), 0);
    printf("recv from server %s\n", buf);
    //关闭套接字
    close(cliFd);
    return 0;
}


















































   





















2、并发服务器

>>>多进程的并发服务器
   >>>多线程的并发服务器
   >>>IO多路复用的并发服务器
  
   >>>多进程的并发服务器

   只要有客户端连接服务器，服务器就创建子进程与客户端通信

   创建子进程后，父进程----继续等待其他客户端的连接
               子进程----与客户端通信
                
   总结：多进程服务器，比较浪费资源，适合于客户端数量较少，但是长连接的情况

服务器代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <signal.h>

void sigFunc(int sigNo)
{
    if(sigNo == SIGCHLD)
    {
        wait(NULL);
    }
}

int main()
{
    //定义结构体变量，作为bind函数的参数
    struct sockaddr_in servAddr;
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = PF_INET;
    servAddr.sin_port = htons(8888);
    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    //创建套接字
    //返回值为新创建的socket的文件描述符，失败-1
    int servFd = socket(PF_INET, SOCK_STREAM, 0);
    if(servFd < 0)
    {
        perror("socket error!");
        return -1;
    }
    printf("socket ok!\n");
    //绑定地址信息
    int ret = bind(servFd, (struct sockaddr *)&servAddr, sizeof(servAddr));
    if(ret < 0)
    {
        perror("bind error!");
        close(servFd);
        return -1;
    }
    printf("bind ok!\n");
    //创建监听队列
    ret = listen(servFd, 10);
    if(ret < 0)
    {
        perror("listen error!");
        close(servFd);
        return -1;
    }
    printf("listening.....\n");

    while(1)
    {
        //接收连接请求
        int connFd = accept(servFd, NULL, NULL);
        if(connFd < 0)
        {
            perror("accept error!");
            close(servFd);
            return -1;
        }
        printf("accept ok!\n");

        //创建子进程
        pid_t pid;
        while((pid = fork()) < 0);
        if(0 == pid)
        {
            close(servFd);
            char buf[1024] = {0};
            while(1)
            {
                //接收消息
                memset(buf, 0, sizeof(buf));
                ret = recv(connFd, buf, sizeof(buf), 0);
                if(ret < 0)
                {
                    perror("recv error!");
                    close(connFd);
                    return -1;
                }
                else if(0 == ret)
                {
                    printf("client shutdown!\n");
                    break;
                }
                printf("recv from client: %s\n", buf);
                memset(buf, 0, sizeof(buf));
                printf("server:");
                gets(buf);
                send(connFd, buf, sizeof(buf), 0);
            }
            //关闭套接字
            close(connFd);
            exit(0);
        }
        else
        {
            close(connFd);
            signal(SIGCHLD, sigFunc);
        }

    }
    close(servFd);
    return 0;
}




















































































































































客户端代码：

#include<stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>


int main()
{
    //定义结构体变量，该变量保存的服务器的地址信息,作为connect的参数
    struct sockaddr_in servAddr;
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = PF_INET;
    servAddr.sin_port = htons(8888);
    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    //创建套接字
    int cliFd = socket(PF_INET, SOCK_STREAM, 0);
    if(cliFd < 0)
    {
        perror("socket error!");
        return -1;
    }
    printf("socket ok!\n");
    //发起连接请求
    int ret = connect(cliFd, (struct sockaddr *)&servAddr, sizeof(servAddr));
    if(ret < 0)
    {
        perror("connect error!");
        close(cliFd);
        return -1;
    }
    printf("connect ok!\n");
    char buf[1024];
    while(1)
    {
        memset(buf, 0, sizeof(buf));
        printf("client:");
        gets(buf);
        if(0 == strcmp(buf, "quit"))
        {
            break;
        }
        //发送消息
        ret = send(cliFd, buf, sizeof(buf), 0);
        if(ret < 0)
        {
            perror("send error!");
            close(cliFd);
            return -1;
        }
        printf("send ok!\n");

        memset(buf, 0, sizeof(buf));
        recv(cliFd, buf, sizeof(buf), 0);
        printf("recv from server %s\n", buf);
    }
    //关闭套接字
    close(cliFd);
    return 0;
}



























































   
























>>>多线程的并发服务器
    只要有客户端连接服务器，服务器就创建子线程与客户端通信
    由于在创建子线程时，以及销毁子线程时，比较浪费时间，一般可以使用线程池
    多线程存在的问题：存在资源竞争以及同步的问题
    总结：适合于客户端数量较少，但是长连接的情况

服务器代码：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>


void *threadFunc(void *arg)
{
    int connFd = *((int *)arg);
    char buf[1024] = {0};
    while(1)
    {
        memset(buf, 0, sizeof(buf));
        //接收消息
        int ret = recv(connFd, buf, sizeof(buf), 0);
        if(ret < 0)
        {
            perror("recv error!");
            close(connFd);
            pthread_exit((void *)-1);
        }
        else if(0 == ret)
        {
            printf("client shutdown!\n");
            break;
        }
        printf("recv from client: %s\n", buf);

        memset(buf, 0, sizeof(buf));
        printf("server:");
        gets(buf);
        send(connFd, buf, sizeof(buf), 0);
    }
    close(connFd);
    pthread_exit(NULL);
}

int main()
{
    //定义结构体变量，作为bind函数的参数
    struct sockaddr_in servAddr;
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = PF_INET;
    servAddr.sin_port = htons(8888);
    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    //创建套接字
    //返回值为新创建的socket的文件描述符，失败-1
    int servFd = socket(PF_INET, SOCK_STREAM, 0);
    if(servFd < 0)
    {
        perror("socket error!");
        return -1;
    }
    printf("socket ok!\n");
    //绑定地址信息
    int ret = bind(servFd, (struct sockaddr *)&servAddr, sizeof(servAddr));
    if(ret < 0)
    {
        perror("bind error!");
        close(servFd);
        return -1;
    }
    printf("bind ok!\n");
    //创建监听队列
    ret = listen(servFd, 10);
    if(ret < 0)
    {
        perror("listen error!");
        close(servFd);
        return -1;
    }
    printf("listening.....\n");
    while(1)
    {
        //接收连接请求
        int connFd = accept(servFd, NULL, NULL);
        if(connFd < 0)
        {
            perror("accept error!");
            close(servFd);
            return -1;
        }
        printf("accept ok!\n");

        pthread_t th;
        while(pthread_create(&th, NULL, threadFunc, &connFd) < 0);
    }
    //关闭套接字
    close(servFd);
    return 0;
}
































































































































客户端代码：

#include<stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>


int main()
{
    //定义结构体变量，该变量保存的服务器的地址信息,作为connect的参数
    struct sockaddr_in servAddr;
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = PF_INET;
    servAddr.sin_port = htons(8888);
    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    //创建套接字
    int cliFd = socket(PF_INET, SOCK_STREAM, 0);
    if(cliFd < 0)
    {
        perror("socket error!");
        return -1;
    }
    printf("socket ok!\n");
    //发起连接请求
    int ret = connect(cliFd, (struct sockaddr *)&servAddr, sizeof(servAddr));
    if(ret < 0)
    {
        perror("connect error!");
        close(cliFd);
        return -1;
    }
    printf("connect ok!\n");
    char buf[1024];
    while(1)
    {
        memset(buf, 0, sizeof(buf));
        printf("client:");
        gets(buf);
        if(0 == strcmp(buf, "quit"))
        {
            break;
        }
        //发送消息
        ret = send(cliFd, buf, sizeof(buf), 0);
        if(ret < 0)
        {
            perror("send error!");
            close(cliFd);
            return -1;
        }
        printf("send ok!\n");

        memset(buf, 0, sizeof(buf));
        recv(cliFd, buf, sizeof(buf), 0);
        printf("recv from server %s\n", buf);
    }
    //关闭套接字
    close(cliFd);
    return 0;
}











































    
   






































>>>IO多路复用的并发服务器
    适合于客户端数量较多，但是短连接的情况。
    
    
    
    
    
    
    
    
    
    
    
    
    
    
   
TCP服务器模型
m0_72647108的博客
08-03 536
TCP通信
网络编程day4——TCP循环服务器模型与并发服务器模型
weixin_54481049的博客
05-07 1774
只有在当前客户的所有请求都完成后，服务器才能处理下一个客户的连接/服务请求。关键是在某个客户端产生通信套接字后，在recv/send部分用一个while循环，直到此客户端完全结束通讯任务，才会产生新的通信套接字继续通信。并发服务器的设计思想是服务器接受客户端的连接请求后创建子进程来为客户端服务。： 大规模的 Web 服务器（如 Apache）、数据库服务器、在线游戏服务器等，需要处理大量并发连接的应用。TCP服务器接受一个客户端的连接后开始处理，完成了客户的所有请求后断开连接。
TCP/IP四层模型详解
最新发布
sre救赎之路
05-22 1560
网络四层模型是理解现代计算机网络通信的基础，掌握各层的功能、关键协议和数据处理流程，对于网络故障排查、安全防护和系统设计都至关重要。在实际应用中，需根据业务需求选择合适的协议（如 TCP 或 UDP），并结合安全措施保障数据传输的可靠性和安全性。网络四层模型（TCP/IP 模型）是现代计算机网络的基础架构，广泛应用于互联网和企业网络中。本文将从协议分层、数据传输流程、关键协议到实战应用进行全面解析。
IOCP模型TCP服务器
xingoo
10-17 225
IOCP模型TCP服务器 主线程创建监听套接字，创建额外工作线程，关联IOCP，负责等待和接受到来的连接。 调用GetQueuedCompletionStatus函数，函数返回： 1 调用失败 2 套接字被对方关闭 3 请求成功完成 程序首先定义per-handle per-IO的操作数据的结构类型 #define BUFFER_S...
【计算机网络】TCP/IP网络模型(简易版理解)
flyersboy的博客
04-30 686
TCP/IP的网络模型 这个⽹络协议是分层的，每⼀层都有各⾃的作⽤和职责 应用层 ​ 最上层的，也是我们能直接接触到的就是应⽤层（Application Layer），我们电脑或⼿机使⽤的应⽤软件都是在应⽤层实现。那么，当两个不同设备的应⽤需要通信的时候，应⽤就把应⽤数据传给下⼀层，也就是传输层。 ​ **所以，应⽤层只需要专注于为⽤户提供应⽤功能，不⽤去关⼼数据是如何传输的，**就类似于，我们寄快递的时候，只需要把包裹交给快递员，由他负责运输快递，我们不需要关⼼快速是如何被运输的。⽽且应⽤层是⼯作在操
Linux网络编程--9. 服务器模型 非常好 (http://www.fanqiang.com)
时光机器
02-23 1561
Linux网络编程--9. 服务器模型http://linuxc.51.net 作者:hoyt (2001-05-08 11:23:59)    学习过《软件工程》吧.软件工程可是每一个程序员"必修"的课程啊.如果你没有学习过, 建议你去看一看. 在这一章里面,我们一起来从软件工程的角度学习网络编程的思想.在我们写程序之前, 我们都应该从软件工程的角度规
TCP并发服务器模型-多线程TCP服务器
01-18
多线程TCP服务器模型提高了服务器的并发处理能力，但也带来了线程管理的复杂性，包括线程的创建、销毁、同步等问题。在实际应用中，还需要考虑服务器的性能瓶颈、内存占用以及线程安全等因素，合理设计线程数量和...
TCP/IP网络模型详解
qq_42037383的博客
07-17 3486
在计算机网络领域，网络模型通常指的是 OSI（Open Systems Interconnection）参考模型或 TCP/IP（Transmission Control Protocol/Internet Protocol）模型。这些模型描述了网络中数据传输的层次结构，便于理解和设计网络系统。
tcp事件选择模型服务器
10-29
在这个场景下，我们讨论的是一个基于事件选择模型的TCP服务器，其中包含了丰富的注释，有助于学习者深入理解。 事件选择模型，又称为事件驱动模型，主要是通过监听和响应系统中的特定事件来执行相应操作。在服务器...
学习笔记——网络参考模型——TCP/IP模型
灵韵的博客
06-01 3183
整个华为数通学习笔记系列中，本人是以网络视频与网络文章的方式自学的，并按自己理解的方式总结了学习笔记，某些笔记段落中可能有部分文字或图片与网络中有雷同，并非抄袭。TCP/IP标准参考模型将OSI中的数据链路层和物理层合并为网络接入层，这种划分方式其实是有悖于现实协议制定情况的，故融合了TCP/IP标准模型和OSI模型的TCP/IP对等模型被提出，后面的讲解也都将基于这种模型。负责IP组播成员管理的协议。将传输层的数据封装成数据包并完成源站点到目的站点的转发，提供无连接的、不可靠的服务。
TCP/IP 网络模型
weixin_34019144的博客
04-17 640
前言 互联网是怎么构成的，又是怎么运作的？什么是 TCP/IP 网络？为什么远隔万里的计算机可以互相通信？计算机网络作为 IT 行业的基石，是工程师永远绕不开的话题。 计算机网络的分层体系结构 计算机网络是一个非常庞大且复杂的系统，所以在设计之初就严格遵守着「分层」的设计理念。分层将庞大的问题细分为了若干个局部的小问题，具有下列好处： 分层隔离 灵...
网络编程之TCP服务器模型
鹰击长空KO的博客
10-18 609
TCP多进程多线程服务器
TCP并发server模型（三）
weixin_34224941的博客
08-11 100
本篇博客讲述的是单client单线程模型，该模型相同由主进程统一accept，仅仅是将fork改为了pthread_create。 与进程相比，线程有非常多长处（速度快，占用资源少。数据能够共享）。 该模型结构如图所看到的： 与上一篇博客讲述的模型非常相似，源码同上一篇相比仅仅有少量更改而已，亦不解说。 服务器端代码例如以下： /* author:arvik pu...
八、Linux下的网络服务器模型
dichuangheng8094的博客
03-07 188
八、Linux下的网络服务器模型 服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器，按处理方式来分有循环服务器和并发服务器。 在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。 目前最常用...
TCP-网络服务器模型
abisineer的专栏
11-07 640
导读： 　　C语言 tcp 网络 编程 　　Linux下各类TCP网络服务器的实现源代码 　　大家都知道各类网络服务器程序的编写步骤，并且都知道网络服务器就两大类：循环服务和并发服务。这里附上源代码来个小结吧。 　　首先，循环网络服务器编程实现的步骤是这样的： 　　建立socket（这里用到socket()函数及函数setsockopt()） 　　| 　　| 　　/|/ 　　把socket和IP地
Tcp网络模型
weixin_50589168的博客
01-19 303
要摸清网络，那么第一步肯定是要清楚网络协议的分层结构，用上帝视角来看网络。 对于同一台设备上的进程间通信，有很多种方式，比如有管道、消息队列、共享内存、信号等方式，而对于不同设备上的进程间通信，就需要网络通信，而设备是多样性的，所以要兼容多种多样的设备，就协商出了一套通用的网络协议。 网络协议是分层的，每一层都有各自的作用和职责，接下来就分别对每一层进行介绍。 应用层 最上层的，也是我们能直接接触到的就是应用层（Application Layer），终端设备使用的应用软件是在应用层实现。如果当两个不同设备的
TCP套接字编程模型及实例
weixin_33978016的博客
07-28 261
摘要：     本文讲述了TCP套接字编程模块，包括服务器端的创建套接字、绑定、监听、接受、读/写、终止连接，客户端的创建套接字、连接、读/写、终止连接。先给出实例，进而结合代码分析。   PS：本文权当复习套接字编程的读书笔记。   一、TCP套接字编程模型     同一台计算机上运行的进程可以利用管道、消息队列、信号量、共享内存等进行相互通信，不同计算机上运行的进程可以通过套接字网...
TCP/IP网络模型
ranyizhang的博客
08-02 4193
TCP/IP网络模型 计算机与网络设备需要相互通信，双方就必须基于相同的方法。如何探测到目标、由哪一边先发起通信、使用哪种语言进行通信、怎样结束通信等规则都需要提前确定。不同的硬件、不同的操作系统之间的通信，所有的这一切都需要一种规则，这种规则就叫做协议。 TCP/IP是互联网相关的各类协议族的总称，例:TCP,UDP,IP,FTP,HTTP,ICMP,SMTP等都属于TCP/IP族内的协议。 TCP/IP模型是互联网的基础，他是一系列网络协议的总称。这些协议可划分为四层，分别为链路层(物理层、数据链路层)
TCP循环服务器模型
09-03
TCP循环服务器模型是一种常见的网络通信模式，它基于TCP协议构建，常用于服务端程序设计。这种模型通常包括以下几个步骤： 1. **监听连接**：服务器启动后，会创建一个或多条TCP套接字，进入listen状态，等待客户端发起连接请求。 2. **接受连接**：当有新的客户端连接时，服务器会通过accept()系统调用接收这个连接，形成一个新的独立的套接字对。 3. **处理请求**：对于每个新连接，服务器会创建一个新的线程或者进程来处理客户端的数据请求，比如读取数据、解析请求、执行业务逻辑等。 4. **响应数据**：服务器根据处理结果生成响应，并通过套接字发送给客户端。 5. **保持连接**：在完成一次请求后，服务器可以选择继续监听新的请求，还是关闭当前连接并结束处理过程。如果设置成长连接（如HTTP/1.1的Keep-Alive），则可以维持一段时间，直到连接因超时或其他原因而终止。 6. **循环重复**：服务器会不断重复上述步骤，直到主动停止或者因为资源耗尽等原因自动终止。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值