服务器模型、网络超时检测

最新推荐文章于 2024-05-21 22:59:12 发布
最新推荐文章于 2024-05-21 22:59:12 发布
阅读量141 收藏
点赞数 5
分类专栏： # 网络编程 文章标签： 网络 服务器 tcp/ip linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41566483/article/details/134499512
版权

服务器模型

循环服务器

每次只能处理一个客户端，当前客户端退出后，才能处理下一个客户端。
（循环处理客户端，因此不能做耗时动作。）

练习: 实现 TCP 全双工

利用进程实现
利用线程实现

并发服务器

同一时刻可以响应多个客户端的请求。

多进程实现并发（不建议）

// ser_pro.c


// cli_pro.c

多线程实现并发

每来一个客户端连接，开一个子线程来专门处理客户端的数据，实现简单，资源占用少。

// ser_thr.c

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

void *handler(void *arg){

    int fd = *(int *)arg;
    char buf[256] = {};
    while (1){
        int receriver = recv(fd, buf, sizeof(buf), 0);
        if (receriver < 0){
            perror("Failed to receive");
            return NULL;
        } else if (receriver == 0){
            printf("Client exited. \n");
            break;
        } else {
            printf("%s\n", buf);
        }
    }
    close(fd);
    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    if (argc != 2){
        printf("Please input %s <port>. \n", argv[0]);
        return -1;
    }
    
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0){
        perror("Failed to create a socket");
        return -1;
    }
    printf("sockfd: %d\n", sockfd);

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0){
        perror("Failed to bind");
        return -1;
    }

    if (listen(sockfd, 6) < 0){
        perror("Failed to listen");
        return -1;
    }

    struct sockaddr_in caddr;
    socklen_t length = sizeof(caddr);

    char buf[256] = {};
    while (1){

        int accfd = accept(sockfd, (struct sockaddr *)&caddr, &length);
        if (accfd < 0){
            perror("Failed to accept");
            return -1;
        }
        printf("Client IPv4: %s\t\tport: %d\n", 
               inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

        pthread_t tid;
        pthread_create(&tid, NULL, handler, &accfd);
        pthread_detach(tid);

    }

    close(sockfd);    
    return 0;
}

// cli_thr.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <pthread.h>

void *mythread_recv(void *arg)
{
    int fd = *((int *)arg);
    char buf[256] = {};
    while (1){
        int receriver = recv(fd, buf, sizeof(buf), 0);
        if (receriver < 0){
            perror("recv is err:");
            return NULL;
        } else {
            printf("%s\n", buf);
        }
    }
    pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
    if (argc != 3){
        printf("Please input %s <ip> <port>. \n", argv[0]);
        return -1;
    }

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0){
        perror("Failed to create a socket");
        return -1;
    }

    struct sockaddr_in caddr;
    caddr.sin_family = AF_INET;
    caddr.sin_port = htons(atoi(argv[2]));
    caddr.sin_addr.s_addr = inet_addr(argv[1]);

    if (connect(sockfd, (struct sockaddr *)&caddr, sizeof(caddr)) < 0){
        perror("Failed to connect");
        return -1;
    }

    pthread_t tid;
    pthread_create(&tid, NULL, mythread_recv, &sockfd);
    pthread_detach(tid);

    char buf[128] = "";
    while (1){
        fgets(buf, sizeof(buf), stdin);
        if (buf[strlen(buf)-1] == '\n')
            buf[strlen(buf)-1] = '\0';

        if (!strcmp(buf, "quit")){
            printf("Client exited. \n");
            break;
        }

        send(sockfd, buf, sizeof(buf), 0);
    }
    close(sockfd);
    return 0;
}

实现效果如下：
在这里插入图片描述

// server.c

#include "mymacro.h"

linklist_t ph;

void *server_send(void *arg){

    linklist_t p;
    char buf[256] = {};

    while (1){
        fgets(buf, sizeof(buf), stdin);
        if (buf[strlen(buf)-1] == '\n')
            buf[strlen(buf)-1] = '\0';

        p = (linklist_t)arg;
        while (p->next){
            p = p->next;
            send(p->fd, buf, sizeof(buf), 0);
        }
    }
    // pthread_exit(NULL);			// 服务器端不需要退出此线程
}

void *server_recv(void *arg){

    int fd = *(int *)arg;
    char buf[256] = {};
    while (1){
        int receriver = recv(fd, buf, sizeof(buf), 0);
        if (receriver < 0){
            perror("Failed to receive");
            return NULL;
        } else if (receriver == 0){
            DeleteFromLinkedList(ph, fd);
            printf("Client[%d] exited. \n", fd);
            break;
        } else {
            printf("Client[%d]: %s\n", fd, buf);
        }
    }
    close(fd);
    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    if (argc != 2){
        printf("Please input %s <port>. \n", argv[0]);
        return -1;
    }
    
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0){
        perror("Failed to create a socket");
        return -1;
    }
    // printf("sockfd: %d\n", sockfd);

    ADDRIN saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    socklen_t length = sizeof(caddr);

    if (bind(sockfd, (ADDR *)&saddr, sizeof(saddr)) < 0){
        perror("Failed to bind");
        return -1;
    }

    if (listen(sockfd, 6) < 0){
        perror("Failed to listen");
        return -1;
    }

    ph = CreateLinkedList();
    head = ph;
    char buf[256] = {};
    pthread_t tid_recv, tid_send;
    pthread_create(&tid_send, NULL, server_send, head);
    pthread_detach(tid_send);

    while (1){
        int accfd = accept(sockfd, (ADDR *)&caddr, &length);
        if (accfd < 0){
            perror("Failed to accept");
            return -1;
        }
        // printf("Client IPv4: %s\t\tport: %d\n", 
        //        inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

        InsertIntoLinkedList(head, accfd);
        ShowLinkedList(head);

        pthread_create(&tid_recv, NULL, server_recv, &accfd);
        pthread_detach(tid_recv);
    }

    close(sockfd);    
    return 0;
}
```c
// client.c

#include "mymacro.h"

void *client_recv(void *arg)
{
    int fd = *((int *)arg);
    char buf[256] = {};
    while (1){
        int receriver = recv(fd, buf, sizeof(buf), 0);
        if (receriver < 0){
            perror("recv is err:");
            return NULL;
        } else {
            printf("Server: %s\n", buf);
        }
    }
    pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
    if (argc != 3){
        printf("Please input %s <ip> <port>. \n", argv[0]);
        return -1;
    }

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0){
        perror("Failed to create a socket");
        return -1;
    }

    struct sockaddr_in caddr;
    caddr.sin_family = AF_INET;
    caddr.sin_port = htons(atoi(argv[2]));
    caddr.sin_addr.s_addr = inet_addr(argv[1]);

    if (connect(sockfd, (struct sockaddr *)&caddr, sizeof(caddr)) < 0){
        perror("Failed to connect");
        return -1;
    }

    pthread_t tid;
    pthread_create(&tid, NULL, client_recv, &sockfd);
    pthread_detach(tid);

    char buf[256] = {};
    while (1){
        fgets(buf, sizeof(buf), stdin);
        if (buf[strlen(buf)-1] == '\n')
            buf[strlen(buf)-1] = '\0';

        if (!strcmp(buf, "quit")){
            printf("Client exited. \n");
            break;
        }

        send(sockfd, buf, sizeof(buf), 0);
    }
    
    close(sockfd);
    return 0;
}

// mymacro.h

#ifndef __MYMACRO_H_
#define __MYMACRO_H_

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h> 
#include <sys/socket.h> 
#include <netinet/in.h>    
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>

#define N 32

typedef struct sockaddr_in ADDRIN;
typedef struct sockaddr ADDR;

typedef struct linkedlist{
    int fd;
    struct linkedlist *next;
} linknode_t, *linklist_t;

linklist_t head;


/* *************** 以下函数可写到一个新的.c文件中 **************** */

linklist_t CreateLinkedList(){

    linklist_t p = (linklist_t)malloc(sizeof(linknode_t));
    if (!p){
        perror("Failed to create a linked list");
        return NULL;
    }

    p->next = NULL;
    return p;
}

int InsertIntoLinkedList(linklist_t p, int data){

    linklist_t pnw = (linklist_t)malloc(sizeof(linknode_t));
    if (!pnw){
        perror("Failed to create a new node");
        return -1;
    }

    pnw->fd = data;

    while (p->next)
        p = p->next;
    
    p->next = pnw;
    pnw->next = NULL;
    return 0;
}

int DeleteFromLinkedList(linklist_t p, int data){

    while (p->next){
        if (p->next->fd == data){
            linklist_t pdel = p->next;
            p->next = pdel->next;
            free(pdel);
            pdel = NULL;
        }
        else                // 必须加，否则段错误
            p = p->next;
    }

    return 0;
}

void ShowLinkedList(linklist_t p){
    p = p->next;
    while (p){
        printf("%d ", p->fd);
        p = p->next;
    }
    putchar(10);
}

#endif

实现效果如下：
在这里插入图片描述

IO 多路复用

借助 select, poll, epoll 机制，将新连接的客户端描述符添加到描述符表中，只需要一个线程即可处理所有的客户端连接，在嵌入式开发中应用广泛，但代码复杂度较高。
( 点此跳转到 IO 多路复用 )
在这里插入图片描述

总结
在这里插入图片描述

网络超时检测

使用原因：
避免进程在没有数据时无休止阻塞，当到达设定的时间， 进程从原操作返回，继续执行下面的代码。

通过函数参数设置超时

select 超时检测

在这里插入图片描述
在这里插入图片描述

// 无超时

	fd_set readfds, tempfds;		// 1. 先构造一张有关文件描述符的表
    FD_ZERO(&readfds);				// 2. 清空表
    FD_SET(0, &readfds);			// 3. 将关心的文件描述符添加到表中
    FD_SET(fd, &readfds);
    int maxfd = fd;

    char buf[256] = {};
    while (1){
        tempfds = readfds;			// 4. 备份表
        select(maxfd+1, &tempfds, NULL, NULL, NULL);	// 5. 调用 select 函数

        if (FD_ISSET(0, &tempfds)){						// 6. 产生事件，进行相应处理
            fgets(buf, sizeof(buf), stdin);
            if (buf[strlen(buf)-1] == '\n')
                buf[strlen(buf)-1] = '\0';
            printf("Keyboard: %s\n", buf);
        }
        if (FD_ISSET(fd, &tempfds)){
            int len = read(fd, buf, sizeof(buf));
            buf[len] = '\0';
            printf("Mouse: %s\n", buf);
        }
    }

// 添加超时

	fd_set readfds, tempfds;		// 1. 先构造一张有关文件描述符的表
    FD_ZERO(&readfds);				// 2. 清空表
    FD_SET(0, &readfds);			// 3. 将关心的文件描述符添加到表中
    FD_SET(fd, &readfds);
    int maxfd = fd;

    char buf[256] = {};
    while (1){
        tempfds = readfds;			// 4. 备份表
        struct timeval tiv = {3, 0};		// 3s + 0 ms
        int ret = select(maxfd+1, &tempfds, NULL, NULL, &tiv);	// 5. 调用 select 函数
        if (ret < 0){
            perror("Failed to select");
            return -1;
        } else if (ret == 0){
            printf("Timeout! \n");
            continue;
        } else {}

        if (FD_ISSET(0, &tempfds)){						// 6. 产生事件，进行相应处理
            fgets(buf, sizeof(buf), stdin);
            if (buf[strlen(buf)-1] == '\n')
                buf[strlen(buf)-1] = '\0';
            printf("Keyboard: %s\n", buf);
        }
        if (FD_ISSET(fd, &tempfds)){
            int len = read(fd, buf, sizeof(buf));
            buf[len] = '\0';
            printf("Mouse: %s\n", buf);
        }
    }

在这里插入图片描述

poll 超时检测

在这里插入图片描述

// 无超时

    struct pollfd fds[64];
    fds[0].fd = 0;
    fds[0].events = POLLIN;
    fds[1].fd = sockfd;
    fds[1].events = POLLIN;    
    int last = 1;

    char buf[256] = {};
    int accfd, receiver;
    struct sockaddr_in caddr;
    int length = sizeof(caddr);
    while (1){
        int getpoll = poll(fds, last+1, -1);
        if (getpoll < 0){
            perror("Failed to poll");
            return -1;
        }
        for (int i = 0; i < last+1; i++){
            if (fds[i].revents == POLLIN){
                if (fds[i].fd == 0){
                    /* 相应处理 */
                }
                if (fds[i].fd == sockfd){
                    /* 相应处理 */
                }
            }
        }
    }

// 添加超时

    struct pollfd fds[64];
    fds[0].fd = 0;
    fds[0].events = POLLIN;
    fds[1].fd = sockfd;
    fds[1].events = POLLIN;    
    int last = 1;

    char buf[256] = {};
    int accfd, receiver;
    struct sockaddr_in caddr;
    int length = sizeof(caddr);
    while (1){
        int getpoll = poll(fds, last+1, 3000);			// 设置 3000ms 超时检测
        if (getpoll < 0){
            perror("Failed to poll");
            return -1;
        } else if (getpoll == 0){
            printf("Timeout! \n");
            continue;
        } else {}
        
        for (int i = 0; i < last+1; i++){
            if (fds[i].revents == POLLIN){
                if (fds[i].fd == 0){
                    /* 相应处理 */
                }
                if (fds[i].fd == sockfd){
                    /* 相应处理 */
                }
            }
        }
    }

epoll 超时检测

在这里插入图片描述

// 无超时

	struct epoll_event ev, eves[16];

    ev.data.fd = 0;
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ev);

    ev.data.fd = sockfd;
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);

    char buf[256] = {};
    while (1){ 
        int num = epoll_wait(epfd, eves, 16, -1);
        if (num < 0){
            perror("Failed to epwait");
            return -1;
        }
        for (int i = 0; i < num; i++){
            if (eves[i].data.fd == 0){
                /* 相应处理 */
            }
            if (eves[i].data.fd == sockfd){
                /* 相应处理 */
            }
        }
    }

// 添加超时

	struct epoll_event ev, eves[16];

    ev.data.fd = 0;
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ev);

    ev.data.fd = sockfd;
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);

    char buf[256] = {};
    while (1){ 
        int num = epoll_wait(epfd, eves, 16, 3000);			// 设置 3000ms 超时检测
        if (num < 0){
            perror("Failed to epwait");
            return -1;
        } else if (num == 0){
            printf("Timeout! \n");
            continue;
        } else {}
        
        for (int i = 0; i < num; i++){
            if (eves[i].data.fd == 0){
                /* 相应处理 */
            }
            if (eves[i].data.fd == sockfd){
                /* 相应处理 */
            }
        }
    }

setsockopt() 设置套接字属性

#include<sys.socket.h>  
#include<sys/types.h> 
#include<sys/time.h>
int setsockopt(int sockfd, int level, int optname, void *optval, socklen_t optlen);

功能：获得/设置套接字属性
参数：
    sockfd：	套接字描述符
    level：		协议层
    optname：	选项名
    optval:		选项值
    optlen:		选项值大小指针
返回值：		成功： 0                
			失败： -1

在这里插入图片描述
在这里插入图片描述

端口与地址复用

// 端口与地址复用 server.c

	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0){
        perror("Failed to create a socket");
        return -1;
    }
    printf("sockfd: %d\n", sockfd);

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

	int op = 1;			// 非 0 即可
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &op, sizeof(op));

    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0){
        perror("Failed to bind");
        return -1;
    }

超时检测，打断接下来的阻塞

	while (1){

        struct timeval tiv = {2, 500};			// 设置 2.5s 超时检测
        setsockopt(acceptfd, SOL_SOCKET, SO_RCVTIMEO, &tiv, sizeof(tiv));
        
        int recvbyte = recv(acceptfd, buf, sizeof(buf), 0);        
        if (recvbyte < 0){
            perror("Failed to receive");
            // return -1;			// 注释掉，每2.5s接收不到客户端消息，打印一次上一行代码
        } else if (recvbyte == 0){
            printf("Client exited\n");
            break;
        } else {
            if (!strcmp(buf, "quit")){
                flag = 1;
                break;
            }
            printf("%s\n", buf);
        }
    }

在这里插入图片描述

alarm() 定时器 + sigaction() 修改信号的行为

alarm() 定时器

若 alarm(n); 则 n 秒后，会有 SGIALRM信号 产生，从而终止程序。

// 程序退出

alarm(2);

while (1){
    
}
// 2s后，程序退出，打印 “闹钟” 或 "Alarm clock"

但将 alarm(n); 置于死循环中，则不会终止程序。

while (1){
    alarm(2);
}
// 死循环

// 程序退出

char buf[64] = {};
while (1){
    alarm(2);
    fgets(buf, sizeof(buf), stdin);		// 有阻塞		// 不输入任何内容
}
// 2s后，程序退出，打印 “闹钟” 或 "Alarm clock"

sigaction 修改信号的行为

#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

功能：对接收到的指定信号处理   
参数: 1. signum  信号	
      2. act：设置新行为   oldact：设置旧行为 
返回值： 成功： 0
        失败： -1


    结构体如下:  
           struct sigaction {     
                void (*sa_handler)(int); 			// 函数指针
                其他的结构体成员如mark(信号集)，flag(对信号的标记)都不常用
           };

==================== 需要定义一个函数 ====================

                void handler(int sig)
                {
                    printf("timeout .....\n");
                }

在这里插入图片描述

超时检测

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig){
    printf("Timeout! \n");
}

int main(int argc, char const *argv[])
{
    struct sigaction act;
    sigaction(SIGALRM, NULL, &act);     // 获取 SIGALRM信号 原来的属性
    act.sa_handler = handler;           // 修改属性
    sigaction(SIGALRM, &act, NULL);     // 写回属性

    char buf[64] = {};
    while (1){
        alarm(2);						// 2s后，产生一个 SIGALRM信号
        if (fgets(buf, sizeof(buf), stdin) == NULL){
            perror("Failed to get buffer");
            continue;
        }
        printf("Nothing. \n");
    }
    return 0;
}

运行结果如下：
在这里插入图片描述
在这里插入图片描述

_小白__
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码） 技术框架： 1. 线程池 + 非阻塞 socket + epoll + 事件处理的并发模型 ...5. 利用链表数据结构实现心跳机制（超时检测处理）。
大规模集群中一种自适应可扩展的RPC超时机制
02-22
在其控制下,客户端超时值可以根据网络和服务器的拥塞情况动态地调整设置,而且服务器可以通过额外消息传递通知客户端修改原超时值.经过一系列的模拟和验证,其结果表明,AST 是一种更适合的RPC失效检测模型,增强了系统...
Windows Sockets网络编程 总计4个包，part2
11-03
4.1 客户端-服务器模型 4.2 网络程序概览 4.3 socket的打开 4.4 socket的命名 4.4.1 sockaddr结构 4.4.2 sockaddr_in结构 4.4.3 端口号 4.4.4 本地IP地址 4.4.5 什么是socket名称 4.4.6 客户端socket名称是可选的 ...
网络安全复习重点.doc
06-09
状态检测防火墙对每个合法网络连接保存的信息进行检查，包括 源地址、目的地址、协议类型、协议相关信息（如TCP/UDP协议的端口、ICMP协议的 ID号）、连接状态(如TCP连接状态)和超时时间等，防火墙把这些信息叫做状态...
使用MPLS解决BGP的路由黑洞（详解）
qq_64302290的博客
05-18 233
我们知道在MPLS中数据的转发不再依靠路由表而是靠标签（注意：标签是在路由的基础上形成的）。所以在BGP中，我们依靠的就是这个特性来解决BGP的路由黑洞。BGP路由黑洞的解释：BGP的路由黑洞其实就是路由层面可达，数据层面不可达。（你可以收到对方的路由，但是不能和对方通讯。
计算机网络
zengkui198513的博客
05-15 308
上面的每一个问题是每一层都必须面对的也都必须要解决的。每一层而且必须要覆盖上面的信息！
云服务器遇到攻击怎么办，有哪些安全措施
dexunyun的博客
05-18 551
DDoS攻击对云服务器安全构成了严重威胁，但通过采取合适的防护策略，我们可以有效地降低攻击的影响。选择可靠的云服务提供商、部署DDoS防护服务是保护云服务器免受DDoS攻击的有效措施。德迅云安全提供了多种防护解决方案，可以帮助企业有效防止DDoS攻击，保护云服务器的安全，保障业务稳定。
MQTT 异常断开（一）
m0_50668851的博客
05-21 167
MQTT异分析问题总结 前提：MQTT是基于TCP层再次封装，MQTT是不关心TCP层的实现与传输，但是如果TCP链路出现异常（丢失TCP ACK，网络延时TCP ACK等）一定会导致MQTT断开连接。 MQTT代理服务器存在如下问题： a.代理服务器，对于连接时没有及时处理收到模块关于TCP层的 TCP ACK（Seq确认包），出现重传MQTT Connect Ack。模块内部MQTT的处理逻辑，NQTT收到Connect Ack之后，模块已经准备就绪，回码OK， 但是客户......
netstat协议
lovemelovefish的博客
05-15 389
本机各端口的网络连接情况。
文件操作IO&网络编程&网络原理
tulingtuling的博客
05-13 1612
文件操作IO，网络编程，网络原理
0基础如何进入IT行业
2302_76516899的博客
05-19 602
IT（Information Technology，信息技术）行业涵盖了与计算机技术相关的所有领域。主要包括软件开发、硬件维护、网络架构、数据库管理、网络安全、云计算和人工智能等。了解这些领域的基本概念和发展趋势是进入IT行业的第一步。
用UDP写一个回显服务器和一个字典服务器
最新发布
冷瞳的博客
05-21 254
操作系统提供了一些网络通信的api（socket）。1. 读取请求并解析。2. 根据请求计算响应。3. 把响应写回给客户端。
OSPF多区域组网实验（思科）
qq_65150735的博客
05-21 195
OSPF（Open Shortest Path First，开放式最短路径优先）是一种广泛使用的动态路由协议，属于链路状态路由协议。它主要用于在单一自治系统（AS）内部决策路由，并通过传递链路状态信息和使用算法计算最短路径，为数据包选择最佳的路径，实现快速且有效的数据传输。
中国联通国际在商业零售领域的全球网络与SDN网络技术应用
软件开发
05-21 124
针对零售行业在全球各地分支机构的组网与通信需求，中国联通国际可以为其量身定制符合其实际业务场景和未来发展需求的通信解决方案。中国联通国际凭借其在全球范围内的资源布局和先进的网络技术，为商业零售行业提供了强有力的支持。针对零售行业在全球各地分支机构进行组网与通信的需求，中国联通国际通过不断拓展全球资源，并灵活运用先进的移动网络和SDN网络技术，为零售企业量身定制了一系列高效、稳定的解决方案。这张网络不仅支持跨国数据传输，还能根据零售企业的实际需求进行灵活组网，确保数据的安全、稳定传输。
什么是TCP的粘包、拆包问题？
sinat_53467514的博客
05-15 423
TCP粘包和拆包问题是指在进行TCP通信时，因为TCP是面向流的，所以发送方在传输数据时可能会将多个小的数据包粘合在一起发送，而接收方则可能将这些数据包拆分成多个小的数据包进行接收，从而导致数据接收出现错误或者数据粘连的问题。2接收方缓存区大小限制：接收方在接收数据时，如果接收缓存区的大小有限，可能会将一个大的数据包拆分成多个小数据包进行接收，从而导致粘包和拆包问题的出现。80W字面试解析文档、简历模板、学习路线图、java必看学习书籍。资料，我根据我从小白到架构师多年的学习经验整理出来了一份。
rtsp保活的方法
huibin.yun的博客
05-15 416
rtsp协议有建议客户端固定间隔地向服务端发送getparameter信令来保活。比如vlc设置成http模式——就是rtsp over udp模式——下每隔58s会下发get parameter。【linux下使用TCP存活(keepalive)定时器 - CSDN App】http://t.csdnimg.cn/x1a8H。如果没有采用第1条，那么只能采用第2条了。
Kimsuky黑客利用Linux新后门攻击韩国
2401_84205765的博客
05-21 349
朝鲜黑客组织Kimsuki一直在使用一种名为Gomir的新型Linux恶意软件，它是GoBear后门软件的一个版本，通过木马化的软件安装程序提供。金苏基是一名与朝鲜军事情报机构侦察总局(Reconnaissance General Bureau，简称RGB)有关的国家支持的威胁行动者。
HTTP协议
weixin_73252614的博客
05-15 115
3、HTTP协议是无状态的协议：对于事务处理没有记忆能力。每次请求-响应都是独立的。2、基于请求-响应模型的：一次请求对应一次响应。每次请求-响应都是独立的。概念：hrrp，超文本传输协议，规定了浏览器和服务器之间数据传输的规则。1、基于TCP协议：面向连接、安全。缺点：多次请求间不能共享数据。
5.17 作业+思维导图+模拟面试
weixin_45735759的博客
05-17 383
【代码】5.17 作业+思维导图+模拟面试。
突发性能服务器网络连接超时
06-09
这可能是由于许多原因引起的，例如网络故障、服务器故障、防火墙设置等。为了解决这个问题，您可以尝试以下几种方法： 1. 检查您的网络连接是否正常，并确保服务器端也正常连接。 2. 检查您的防火墙设置，确保它们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值