网络编程（学习）2024.9.2

已于 2024-09-04 20:37:31 修改
阅读量333 收藏 13
点赞数 15
分类专栏： 网络编程 文章标签： 网络 学习 linux c语言 超时检测 多进程
于 2024-09-04 20:36:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60450758/article/details/141901618
版权

目录

服务器模型

1.循环服务器

2.并发服务器

（1）多进程模型

多进程特点

多进程案例

（2）多线程模型

多线程特点

多线程案例

网络超时检测

超时检测的必要性

网络超时检测方法

1.自带超时参数的函数

(1)select设置超时

(2)poll设置超时

2.利用setsockopt属性设置

设置sockfd接收超时

设置端口重用

服务器模型

1.循环服务器

一次只有一个客户端可以连接，但是客户端退出以后，下一个客户端可以继续连接

2.并发服务器

同时一时刻可以连接多个客户端，常见：IO多路复用(select、poll、epoll)、多进程、多线程

（1）多进程模型

多进程特点

1.fork之前的代码被复制，但是不会重新执行一遍；fork之后的代码被复制，并且再被执行一遍。
2.fork之后两个进程相互独立，子进程拷贝了父进程的所有代码，但内存空间独立
3.fork之前打开文件，fork之后拿到的是同一个文件描述符，操作的是同一个文件指针

多进程案例
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/select.h>
#include <signal.h>
#include <wait.h>
#define N 64
char buf[N];
pid_t pid;

void father(int sig)
{
    waitpid(-1, NULL, WNOHANG); // 回收子进程资源
}

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = INADDR_ANY;
    socklen_t addrlen = sizeof(saddr);
    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        perror("bind失败");
        close(sockfd);
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        perror("lisren失败");
        close(sockfd);
        return -1;
    }
    printf("listen成功\n");

    while (1)
    {
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
        if (acceptfd < 0)
        {
            perror("accept失败");
            return -1;
        }
        printf("acceptfd:%d\n", acceptfd);
        printf("客户端ip：%s\t 端口号：%d 已连接\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
        pid = fork();
        if (pid == 0)
        {
            // close(sockfd);
            while (1)
            {
                memset(buf, 0, N);
                int ret = recv(acceptfd, buf, N, 0);
                if (ret < 0)
                {
                    perror("recv失败\n");
                    break;
                }
                else if (ret == 0)
                {
                    printf("客户端ip：%s退出\n", inet_ntoa(caddr.sin_addr));
                    break;
                }
                else
                {
                    printf("%s客户端： %s\n", inet_ntoa(caddr.sin_addr), buf);
                }
            }
            close(acceptfd);
            exit(0);
        }
        else
        {
            close(acceptfd);
            signal(SIGCHLD, father);
        }
    }
    return 0;
}

（2）多线程模型

多线程特点

每来一个连接创建一个线程,IO多路复用以外，应用最广泛的并发服务器模型

多线程案例
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

#define N 64

void *mythread(void *arg)
{
    pthread_detach(pthread_self());
    int fd = *((int *)arg);
    free(arg);
    char buf[N];
    while (1)
    {
        memset(buf, 0, N);
        int ret = recv(fd, buf, N, 0);
        if (ret < 0)
        {
            perror("recv失败");
            break;
        }
        else if (ret == 0)
        {
            printf("客户端acceptfd:%d 退出\n", fd);
            close(fd);
            break;
        }
        else
        {
            printf("客户端： %s\n", buf);
        }
    }

    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：%s <port>\n", argv[0]);
        return -1;
    }

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket失败");
        return -1;
    }
    printf("sockfd：%d\n", sockfd);

    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = INADDR_ANY;
    socklen_t addrlen = sizeof(saddr);
    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        perror("bind失败");
        close(sockfd);
        return -1;
    }
    printf("bind成功\n");

    if (listen(sockfd, 7) < 0)
    {
        perror("listen失败");
        close(sockfd);
        return -1;
    }
    printf("listen成功\n");

    while (1)
    {
        int *acceptfd = malloc(sizeof(int)); // 为每个客户端连接分配内存
        if (acceptfd == NULL)
        {
            perror("内存分配失败");
            close(sockfd);
            return -1;
        }

        *acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
        if (*acceptfd < 0)
        {
            perror("accept失败");
            free(acceptfd);
            continue;
        }
        printf("acceptfd: %d\n", *acceptfd);
        printf("客户端ip：%s 端口号：%d 连接\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

        pthread_t tid;
        if (pthread_create(&tid, NULL, mythread, acceptfd) != 0)
        {
            perror("创建线程失败");
            close(*acceptfd);
            free(acceptfd);
            continue;
        }
    }

    close(sockfd);
    return 0;
}

网络超时检测

在网络通信中，很多操作会使得进程阻塞：
TCP套接字中的recv/accept
UDP套接字中的recvfrom

超时检测的必要性

○避免进程在没有数据时无限制地阻塞
○实现某些特定协议要求，比如某些设备规定，发送请求数据后，如果多长时间后没有收到来自设备的回复，需要做出一些特殊处理

网络超时检测方法

1.自带超时参数的函数

例如使用select/poll/epoll函数最后一个参数可以设置超时。

(1)select设置超时

struct timeval tm = {2, 0};//设置2s打算阻塞
sret = select(maxfd + 1, &tempfds, NULL, NULL, &tm);
第五个参数：
struct timeval

{
        long    tv_sec;         /*秒*/
        long    tv_usec;        /*微秒*/
};
 注：select的超时检测不会更新，所以每次重新超时等待之前要更新等待时间

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/select.h>

#define N 64
char buf[N];
#define ERR_MSG(msg)                           \
    do                                         \
    {                                          \
        fprintf(stderr, "line:%d ", __LINE__); \
        perror(msg);                           \
    } while (0)

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.213");
    socklen_t addrlen = sizeof(saddr);
#if 0
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
#else
    saddr.sin_addr.s_addr = INADDR_ANY;
#endif

    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        ERR_MSG("bind失败");
        close(sockfd);
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        ERR_MSG("lisren失败");
        close(sockfd);
        return -1;
    }
    printf("listen成功\n");

    // 第一步：建表初始化
    fd_set readfds, tempfds;
    FD_ZERO(&readfds);
    FD_SET(sockfd, &readfds);
    FD_SET(0, &readfds);
    int max = sockfd;

    while (1)
    {
        struct timeval tm = {2, 0};
        memset(buf, 0, N);
        tempfds = readfds;
        int ret = select(max + 1, &tempfds, NULL, NULL, &tm);
        if (ret == 0)
        {
            printf("time out\n");
        }
        if (FD_ISSET(sockfd, &tempfds))
        {
            // 4.accept阻塞等待链接
            int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
            if (acceptfd < 0)
            {
                ERR_MSG("accept失败\n");
                return -1;
            }
            printf("acceptfd：%d\n", acceptfd);
            printf("客户端ip：%s\t 端口号：%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
            FD_SET(acceptfd, &readfds);
            if (max < acceptfd)
            {
                max = acceptfd;
            }
        }
        // 5.发送
        else if (FD_ISSET(0, &tempfds))
        {
            scanf("%s", buf);
            for (int i = 4; i <= max; i++)
            {
                if (FD_ISSET(i, &readfds))
                {
                    send(i, buf, N, 0);
                }
            }
        }
        // 6.接收
        for (int n = 4; n <= max; n++)
        {
            if (FD_ISSET(n, &tempfds))
            {
                int ret = recv(n, buf, N, 0);
                if (ret < 0)
                {
                    perror("recv失败");
                    close(sockfd);
                    return -1;
                }
                else if (ret > 0)
                {
                    printf("客户端acceptfd%d：%s\n", n, buf);
                }
                else
                {
                    printf("客户端acceptfd：%d退出\n", n);
                    FD_CLR(n, &readfds);
                    close(n);
                    while (!FD_ISSET(max, &readfds))
                    {
                        max--;
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

(2)poll设置超时

直接在poll(fds, last + 1, 2000);设置，延迟2s；

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <poll.h>

#define N 64
char buf[N];
#define ERR_MSG(msg)                           \
    do                                         \
    {                                          \
        fprintf(stderr, "line:%d ", __LINE__); \
        perror(msg);                           \
    } while (0)

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("192.168.50.213");
    socklen_t addrlen = sizeof(saddr);
    // #if 0
    //     saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    // #else
    //     saddr.sin_addr.s_addr = INADDR_ANY;
    // #endif

    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        ERR_MSG("bind失败");
        close(sockfd);
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        ERR_MSG("lisren失败");
        close(sockfd);
        return -1;
    }
    printf("listen成功\n");

    // 第一步：建表初始化
    struct pollfd fds[100];
    int last = -1;

    // 第二步：填表
    fds[++last].fd = 0;
    fds[last].events = POLLIN;
    fds[last].revents = 0;
    fds[++last].fd = sockfd;
    fds[last].events = POLLIN;
    fds[last].revents = 0;

    while (1)
    {
        memset(buf, 0, N);
        int po = poll(fds, last + 1, 2000);
        if (po == -1)
        {
            perror("select失败");
            close(sockfd);
            return -1;
        }
        for (int i = 0; i <= last; i++)
        {
            if (fds[i].revents == POLLIN)
            {
                if (fds[i].fd == sockfd)
                {
                    // 4.accept阻塞等待链接
                    int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
                    if (acceptfd < 0)
                    {
                        ERR_MSG("accept失败\n");
                        return -1;
                    }
                    printf("acceptfd：%d\n", acceptfd);
                    printf("客户端ip：%s\t 端口号：%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
                    fds[++last].fd = acceptfd;
                    fds[last].events = POLLIN;
                    fds[last].revents = 0;
                }
                else if (fds[i].fd == 0)
                {
                    scanf("%s", buf);
                    for (int j = 2; j <= last; j++)
                    {
                        send(fds[j].fd, buf, N, 0);
                    }
                }
                else
                {
                    int ret = recv(fds[i].fd, buf, N, 0);
                    if (ret < 0)
                    {
                        perror("recv失败");
                        close(sockfd);
                        return -1;
                    }
                    else if (ret > 0)
                    {
                        printf("客户端%s：%s\n", inet_ntoa(caddr.sin_addr), buf);
                    }
                    else
                    {
                        printf("客户端acceptfd：%d退出\n", fds[i].fd);
                        close(fds[i].fd);
                        fds[i] = fds[last];
                        last--;
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

2.利用setsockopt属性设置

Linux中socket属性

API接口
功能：设置/获取网络属性;
#include <sys/types.h>     
#include <sys/socket.h>

int getsockopt(int sockfd, int level, int optname,void *optval, socklen_t *optlen);
int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);
参数：
        int sockfd：指定要设置/获取哪个套接字的属性;
        int level：指定要控制的协议层次;
                SOL_SOCKET：应用层 通用套接字选项;  man 7 socket
                IPPROTO_TCP：TCP选项               man 7 TCP
                IPPROTO_UDP：UDP选项               man 7 UDP
                IPPROTO_IP：IP选项;                man 7 IP
        int optname：指定要控制的内容，指定控制方式；
                 --- SOL_SOCKET: man 7 socket -----
                SO_REUSEADDR：允许端口快速重用        optval: int*
                SO_BROADCAST：允许广播        optval: int*   
                SO_RCVBUF/SO_SNDBUF：接收缓冲区 发送缓冲区大小
                SO_RCVTIMEO/SO_SNDTIMEO：接收超时时间，发送超时时间

        void *optval：根据optname不同，该类型不同;
        socklen_t optlen/socklen_t *optlen：真实的optval指针指向的内存空间的大小;
返回值：
        成功:返回0
        失败:返回-1

设置sockfd接收超时

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

#define ERR_MSG(msg)                           \
    do                                         \
    {                                          \
        fprintf(stderr, "line:%d ", __LINE__); \
        perror(msg);                           \
    } while (0)

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.213");
    socklen_t addrlen = sizeof(saddr);
#if 0
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
#else
    saddr.sin_addr.s_addr = INADDR_ANY;
#endif
    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        perror("bind失败");
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        ERR_MSG("lisren失败");
        return -1;
    }
    printf("listen成功\n");
    struct timeval val = {2, 0};
    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &val, sizeof(val));
    while (1)
    {
        // 4.accept阻塞等待链接
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
        if (acceptfd < 0)
        {
            if (errno == 11)
            {
               char a[10];
               printf("accept超时，是否继续，继续请输入yes，退出请输入no\n");
               scanf(" %s", a);
               if (strcmp(a, "yes") == 0)
               {
                   continue;
               }
               if (strcmp(a, "no") == 0)
               {
                   break;
               }
               else
               {
                   printf("输入错误，请重新输入\n");
                   continue;
               }
            }
            perror("accept失败");
            return -1;
        }
        printf("acceptfd：%d\n", acceptfd);
        printf("客户端ip：%s\t 端口号：%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

        // 5.发送
#define N 64
        char buf[N];
        while (1)
        {
            memset(buf, 0, N);
            int ret = recv(acceptfd, buf, N, 0); // MSG_DONTWAIT
            if (ret < 0)
            {
                if (errno == 11)
                {
                    printf("读缓存区内没数据\n");
                    continue;
                }
                else
                {
                    perror("recv失败\n");
                    return -1;
                }
            }
            else if (ret == 0)
            {
                printf("客户端ip：%s退出\n", inet_ntoa(caddr.sin_addr));
                close(acceptfd);
                break;
            }
            else
            {
                printf("客户端%s\n", buf);
            }
        }
    }

    close(sockfd);
    return 0;
}

设置端口重用

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

#define ERR_MSG(msg)                           \
    do                                         \
    {                                          \
        fprintf(stderr, "line:%d ", __LINE__); \
        perror(msg);                           \
    } while (0)

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.213");
    socklen_t addrlen = sizeof(saddr);
#if 0
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
#else
    saddr.sin_addr.s_addr = INADDR_ANY;
#endif
    int flag;
    socklen_t len = sizeof(flag);
    getsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag, &len);
    flag = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag, len);
    printf("flag:%d\n", flag);
    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        perror("bind失败");
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        ERR_MSG("lisren失败");
        return -1;
    }
    printf("listen成功\n");
    while (1)
    {
        // 4.accept阻塞等待链接
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
        if (acceptfd < 0)
        {
            perror("accept失败");
            return -1;
        }
        printf("acceptfd：%d\n", acceptfd);
        printf("客户端ip：%s\t 端口号：%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

        // 5.发送
#define N 64
        char buf[N];
        while (1)
        {
            memset(buf, 0, N);
            int ret = recv(acceptfd, buf, N, 0); // MSG_DONTWAIT
            if (ret < 0)
            {
                if (errno == 11)
                {
                    printf("读缓存区内没数据\n");
                    continue;
                }
                else
                {
                    perror("recv失败\n");
                    return -1;
                }
            }
            else if (ret == 0)
            {
                printf("客户端ip：%s退出\n", inet_ntoa(caddr.sin_addr));
                close(acceptfd);
                break;
            }
            else
            {
                printf("客户端%s\n", buf);
            }
        }
    }

    close(sockfd);
    return 0;
}
何物爱惜雨#1110
关注
  • 15
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2024前端面试题！（附答案及解析）（2024.8月最新版）
这世上从不缺让人上头的新鲜感，能顾及你情绪的人实属难得。
03-27 14万+
2024前端面试题！面试宝典！总结心得！（附答案及解析）会持续更新哦！（2024.8月最新版）感谢支持，你们的鼓励是我的动力！
PyCharm 2024.1 最新变化，最新更新亮点汇总
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
04-07 6452
PyCharm 2024.1 发布了，带来了针对 Hugging Face 模型和数据集的快速文档预览、为 JavaScript 和 TypeScript 提供的本地ML基于的全行代码补全、编辑器中的粘性行以及编辑器内代码审查等新特性。这一版本旨在通过增强的代码写作支持、更流畅的导航以及更紧密的版本控制集成，提升开发者的编程效率和体验。PyCharm 2024.1 版本凭借其全面的新特性和改进，再次证明了其作为Python开发者首选IDE的地位。
深度学习笔记（2024.7.22更新）
钅日 勿的博客
07-21 744
主要介绍了深度学习应用的场景，深度学习的框架，并且根据实际展开Pytorch环境的搭建以及深度学习的基本概念（张量）。（2024.7.27有更新）
小样本学习idea（不断更新）（2024.1.30更新）
s_m_c的博客
12-22 1529
同时这个调整的参数站整个网络的很大一部分，占很大一部分的原因是总的网络的参数量很小，所以只需要微调很小的部分参数就能达到不错的效果。匈牙利算法可以用在support 和 query进行特征匹配（多尺度）的过程，这样做的目的是通过匈牙利算法，每个support的能且只能找到与他最匹配的那一个query中的特征，而不会多个相似的特征关注于query中的同一个相似的特征，这样就能不局限于图片的某一个区域，而是同时关注与图片的多个区域，然后再利用多个区域的总和（相当于考虑到各个区域的特征），去进行分类的决策。
YOLOv9论文，2024.02发布
02-26
YOLOv9作为最新一代的目标检测算法，在2024年2月正式发布，其性能表现远超现有实时目标检测器。该研究提出了两个核心概念：可编程梯度信息（Programmable Gradient Information，简称PGI）和基于梯度路径规划的通用...
xueshengcaozuoshouce-2024.zip
05-26
9. **编程与数据分析基础**：对于有需求的学生，手册可能还会介绍编程语言基础（如Python或JavaScript），以及使用数据分析工具（如Excel的数据透视表或Python的Pandas库）进行数据处理和分析。 10. **移动设备应用...
Python（机器学习 人工智能 区块链）项目列表 2023-2024.pdf
04-14
9. **P2252 - 一种用于物联网瓶颈检测的混合深度学习方法** - **简介**：该项目提出了一种混合深度学习框架，用于检测物联网环境中的瓶颈问题。通过对设备数据的分析，可以快速定位网络拥堵或性能下降的原因。 - *...
电路2024复习.zip
06-21
9. 实验与实践：电路理论的学习离不开实验，可能包含基础的电阻测量、电路搭建、电路性能测试等实验项目，帮助学生将理论知识应用于实际操作中。 综上所述，《电路2024复习》的压缩包内容广泛，涵盖了电路理论的...
2024年Burpsuite超详细安装教程.zipburpsuite安装详细教程### 内容概要 本博客为初学者提供了一个关于B
03-10
无论你是编程小白，还是已经有一定编程基础的读者，都可以从本博客中找到适合自己的学习内容。 ### 使用场景及目标 本博客适用于在家、学校或任何学习环境中自学Burpsuite安装和使用。通过跟随博客，读者可以了解...
观测云核心技术解密：eBPF Tracing 实现原理
最新发布
观测云的博客
09-03 562
通过 eBPF，开发者可以在不修改内核源码的情况下，对内核功能进行扩展和监控。eBPF Tracing 利用这一技术，对系统调用、内核函数等进行跟踪，从而实现对应用行为的深入洞察。
计算机网络-VRRP工作原理
Linux基础知识、计算机网络基础学习分享。
09-03 310
初始化状态就是在设备上配置完成时的状态，Master状态为主设备的状态，Nackup状态为备份设备的状态，备份设备会监听主设备发送的Advertisement报文，当定时器超时都没有收到主设备的报文时则备份设备切换为Master状态。R1与R2交换VRRP报文，优先级一样，通过比较接口IP地址选举Master路由器，由于R2的接口IP地址大于R1的接口IP地址，因此R2被选举为Master路由器。进行比较，先比较优先级，优先级大的优先，优先级相等则比较接口IP地址，IP地址大的优先，
【CVPR‘24】BP-Net：用于深度补全的双边传播网络，新 SOTA！
梁瑛平的博客
08-28 753
深度补全任务旨在从稀疏的深度测量数据和同步的彩色图像中生成密集的深度图。现有的最先进方法多为基于传播的，通常作为对初始估计的密集深度的迭代改进。然而，这些初始深度估计通常直接将卷积层应用于稀疏深度图。在本文中，我们提出了一种双边传播网络（BP-Net），在最早阶段进行深度传播，以避免直接在稀疏数据上进行卷积。具体而言，我们的方法通过一个非线性模型从附近的深度测量中传播目标深度，该模型的系数由一个多层感知器生成，并基于辐射差异和空间距离进行调整。
网络编程学习：TCP/IP协议
kkbbaaii的博客
09-01 1450
网络编程学习：TCP/IP协议
动态代理和静态代理的区别，动态代理怎么提高网络安全性
yls5yl的博客
08-28 1127
动态代理通过不断变化的IP地址，不仅在网络匿名性、隐私保护和抗攻击方面具有显著优势，还能有效提升用户的网络安全性。尽管与静态代理相比，动态代理可能在稳定性方面有所欠缺，但在现代复杂的网络环境中，它依然是保障网络安全的强大工具。了解并正确使用动态代理，将帮助用户在网络世界中游刃有余，最大程度地保护自己的隐私和数据安全。
【传输层协议】TCP协议(上) {TCP协议段格式；确认应答机制；超时重传机制；连接管理机制：三次握手、四次挥手}
芥末虾的博客
08-30 1679
【传输层协议】TCP协议(上) {TCP协议段格式；确认应答机制；超时重传机制；连接管理机制：三次握手、四次挥手}
Python的socket库详细介绍
小仙女的博客
09-03 761
socket库是Python标准库的一部分，提供了底层的网络接口，可以用于实现各种网络协议的通信。在网络编程中，socket（套接字）是一种在网络设备之间通信的端点。Python的socket库使得网络编程变得简单且高效，能够处理TCP/IP、UDP等协议。
TCP的连接与断开
sanzailmn的博客
08-29 1498
TCP的连接与断开
Kali学习（ms17-010、ms08-067漏洞复现）
2401_82985722的博客
08-28 1273
因为虚拟机有虚拟网卡，就像在windows系统里玩kali一样，他们的物理层公用一个设备-公用主机硬件，但在应用层上他们是相对独立的-互不干扰，可以同时使用。，通过一个公共的网关访问Internet，就像家里的路由器一样，多台设备连接上网，使用的是同一个外网IP。如果端口开放，就会进行完整的三次握手，成功建立链接，扫描结果中，STATE字段显示为 open。桥接就相当于，将创建的虚拟网卡，变成交换机，与主机的网卡连接，使kali可以上网。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值