TCP并发服务器(多进程与多线程)

news2024/12/25 0:11:56

在这里插入图片描述

欢迎关注博主 Mindtechnist 或加入【Linux C/C++/Python社区】一起探讨和分享Linux C/C++/Python/Shell编程、机器人技术、机器学习、机器视觉、嵌入式AI相关领域的知识和技术。


TCP并发服务器(多进程与多线程)

    • 1. 多进程并发服务器
      • (1)什么是并发
      • (2)多进程并发服务器需要注意的几个要点
      • (3)读时共享写时复制详解
    • 2. 多进程并发服务器代码实现
    • 3. 多线程并发服务器
    • 4. 多线程并发服务器代码实现
    • 5. 扩展:Socket API封装


专栏:《Linux从小白到大神》《网络编程》


1. 多进程并发服务器

我们在上一节写的TCP服务器只能处理单连接,在代码实现时,多进程并发服务器与非并发服务器在创建监听套接字、绑定、监听这几个步骤是一样的,但是在接收连接请求的时候,多进程并发服务器是这样实现的:父进程负责接受连接请求,一旦连接成功,将会创建一个子进程与客户端通信。示意图如下:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eoUooLkG-1676856429297)(Typora_picture_reference/1661857992909.png)]

(1)什么是并发

  • 单核CPU → 多进程/线程并发 → 时间片轮转

  • 并发 → 某一个时间片/点所能处理的任务数

  • 服务器并发:服务器在某个时间点/片所能处理的连接数所能接收的client连接越多,并发量越大

(2)多进程并发服务器需要注意的几个要点

使用多进程的方式来解决服务器处理多连接的问题,需要注意下面几点:

  • 共享:读时共享、写时复制。有血缘关系的进程间将会共享
    • 文件描述符
    • 内存映射区mmap
  • 父进程扮演什么角色?
    • 等待接受客户端连接accept()
      • 有连接的时候通过fork()创建一个子进程。父进程只负责等待客户端连接,即通过accept()阻塞等待连接请求,一旦有连接请求,马上通过fork()创建一个子进程,子进程通过共享父进程的文件描述符来实现和client通信。
      • 将用于通信的文件描述符关闭。accept()接受连接请求后会返回一个用于通信的文件描述符,而父进程的职责是等待连接并fork()创建用于通信的子进程,所以对于父进程来说,用于通信的文件描述符是没有用处的,关闭该文件描述符来节省开销。我们知道,文件描述符是有上限的,最多1024个(0-1023),如果不关闭的话,每次fork()一个子进程都要浪费一个文件描述符,如果进程多了,可能文件描述符就不够用了。
  • 子进程扮演什么角色?
    • 通信。通过共享的父进程accept()返回的文件描述符来与客户端通信。
    • 将用于监听的文件描述符关闭。同样是为了节省资源,子进程被fork()出来后也会拥有一个用于监听的文件描述符(因为子进程是对父进程的拷贝),但是子进程的作用是与客户端通信,所以用于监听的文件描述符对子进程而言并无用处,关闭以节省资源。
  • 创建的子进程个数有限制吗?
    • 受硬件限制
    • 文件描述符默认上限1024
  • 子进程资源回收
    • wait/waitpid
    • 使用信号回收
      • signal
      • sigaction
      • 捕捉信号SIGCHLD

(3)读时共享写时复制详解

首先看图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2isLxIfZ-1676856429298)(Typora_picture_reference/1661859472789.png)]

如果父子进程都只是读数据,那么他们都通过虚拟地址去访问1号物理地址的内容,如果此时父进程修改了数据a=8,那么父进程会先复制一份数据到2号内存,然后修改2号内存的数据,父进程再读的时候就去2号内存读,而子进程依然去1号内存读。如果子进程也要修改这个全局变量,那么子进程也会拷贝一份数据到内存3,然后修改内存3的数据,子进程访问数据时会访问内存3的数据。(多个子进程就会拷贝多份)

2. 多进程并发服务器代码实现

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

// 进程回收函数
void recyle(int num)
{
    pid_t pid;
    while( (pid = waitpid(-1, NULL, WNOHANG)) > 0 )
    {
        printf("child died , pid = %d\n", pid);
    }
}

int main(int argc, const char* argv[])
{
    if(argc < 2)
    {
        printf("eg: ./a.out port\n");
        exit(1);
    }
    struct sockaddr_in serv_addr;
    socklen_t serv_len = sizeof(serv_addr);
    int port = atoi(argv[1]);

    // 创建套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    // 初始化服务器 sockaddr_in 
    memset(&serv_addr, 0, serv_len);
    serv_addr.sin_family = AF_INET;                   // 地址族 
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
    serv_addr.sin_port = htons(port);            // 设置端口 
    // 绑定IP和端口
    bind(lfd, (struct sockaddr*)&serv_addr, serv_len);

    // 设置同时监听的最大个数
    listen(lfd, 36);
    printf("Start accept ......\n");

    // 使用信号回收子进程pcb //这个子进程回收机制会被子进程复制
    struct sigaction act;
    act.sa_handler = recyle;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(SIGCHLD, &act, NULL);

    struct sockaddr_in client_addr;
    socklen_t cli_len = sizeof(client_addr);
    while(1)
    {
        // 父进程接收连接请求
        // accept阻塞的时候被信号中断, 处理信号对应的操作之后(比如子进程终止,收到信号后去回收子进程)
        // 回来之后不阻塞了, 直接返回-1, 这时候 errno==EINTR
        int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
        //解决方法就是,在一个循环中判断,如果accept阻塞过程中被信号打断
        //也就是返回值-1且errno == EINTR,那么再一次调用accept
        //这样accept会再次回到阻塞状态,并且返回值不是-1,也就不会进入循环
        //等到再次被信号打断的时候才会再次进入循环
        /*这里的cfd虽然只定义了一个,但是在每个子进程中都会有一个拷贝,并且修改一个子进程的cfd不会影响其它子进程*/
        while(cfd == -1 && errno == EINTR)
        {
            cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
        }
        printf("connect sucessful\n");
        // 创建子进程
        pid_t pid = fork();
        if(pid == 0)
        {
            close(lfd);
            // child process
            // 通信
            char ip[64];
            while(1)
            {
                // client ip port
                printf("client IP: %s, port: %d\n", 
                       inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                       ntohs(client_addr.sin_port));
                char buf[1024];
                int len = read(cfd, buf, sizeof(buf));
                if(len == -1)
                {
                    perror("read error");
                    exit(1);
                }
                else if(len == 0)
                {
                    printf("客户端断开了连接\n");
                    close(cfd);
                    break;
                }
                else
                {
                    printf("recv buf: %s\n", buf);
                    write(cfd, buf, len);
                }
            }
            // 干掉子进程
            return 0;

        }
        else if(pid > 0)
        {
            // parent process
            close(cfd);
        }
    }

    close(lfd);
    return 0;
}

3. 多线程并发服务器

多线程并发服务器示意图如下:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kq3yPqaI-1676856429299)(Typora_picture_reference/1661859902571.png)]

在多进程模型中,fork得到的子进程会复制父进程的文件描述符cfd等信息,每个进程的cfd都是自己的,操作互不影响。但是线程不同,现在只有主线程的cfd,多个线程间的信息是共享的,假如说传递给每个子线程的cfd都是同一个,那么线程1修改该文件描述符指向的内容会影响到线程2的通信,因为它们共享这一个文件描述符。所以这里需要建立一个文件描述符数组,每个子线程对应数组中的一个文件描述符。

另外连接主线程的client是哪一个,也就是说哪个client对应和哪个子线程通信,这也需要把和子线程通信的client的ip和port传给和该client通信的子线程,这样子线程才能知道通信的客户端的ip和port。

于是我们需要创建一个结构体数组,每个子线程对应结构体数组中的一个成员,而结构体数组中的每个成员将作为参数传递给子进程的回调函数。

归根到底就是因为,进程是独立的,线程是共享的。

线程共享下面的资源:

  • 全局数据区
  • 堆区
  • 一块有效内存的地址,比如说把线程1的一块内存的地址传给线程2,那么线程2也可以操作这块内存。

4. 多线程并发服务器代码实现

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

// 自定义数据结构 //把线程处理函数所需要的信息封装进来
typedef struct SockInfo
{
    int fd; // 文件描述符
    struct sockaddr_in addr; //ip地址结构体
    pthread_t id; //线程id
}SockInfo;

// 子线程处理函数
void* worker(void* arg)
{
    char ip[64];
    char buf[1024];
    SockInfo* info = (SockInfo*)arg;
    // 通信
    while(1)
    {
        printf("Client IP: %s, port: %d\n",
               inet_ntop(AF_INET, &info->addr.sin_addr.s_addr, ip, sizeof(ip)),
               ntohs(info->addr.sin_port));
        int len = read(info->fd, buf, sizeof(buf));
        if(len == -1)
        {
            perror("read error");
            pthread_exit(NULL); //只退出子线程
        //exit(1); //exit会把主线程也一块退出
        }
        else if(len == 0)
        {
            printf("客户端已经断开了连接\n");
            close(info->fd);
            break;
        }
        else
        {
            printf("recv buf: %s\n", buf);
            write(info->fd, buf, len);
        }
    }
    return NULL;
}

int main(int argc, const char* argv[])
{
    if(argc < 2)
    {
        printf("eg: ./a.out port\n");
        exit(1);
    }
    struct sockaddr_in serv_addr;
    socklen_t serv_len = sizeof(serv_addr);
    int port = atoi(argv[1]);

    // 创建套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    // 初始化服务器 sockaddr_in 
    memset(&serv_addr, 0, serv_len);
    serv_addr.sin_family = AF_INET;                   // 地址族 
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
    serv_addr.sin_port = htons(port);            // 设置端口 
    // 绑定IP和端口
    bind(lfd, (struct sockaddr*)&serv_addr, serv_len);

    // 设置同时监听的最大个数
    listen(lfd, 36);
    printf("Start accept ......\n");

    int i = 0;
    SockInfo info[256]; //每个线程对应数组的一个元素,最多256个线程
    // 规定 fd == -1  说明这是一个无效文件描述符,也就是说这个文件描述符是空闲的,没被占用
    for(i=0; i<sizeof(info)/sizeof(info[0]); ++i)
    {
        info[i].fd = -1; //所有文件描述符全部初始化为-1
    }

    socklen_t cli_len = sizeof(struct sockaddr_in);
    while(1)
    {
        // 选一个没有被使用的, 最小的数组元素
        //因为有可能我们使用的文件描述符对应数组下标i已经累加到了100,但是前面
        //99个都已经被释放了(断开连接了),我们最好选用一个当前空闲的数组下标最小
        //的文件描述符,以合理利用资源
        for(i=0; i<256; ++i)
        {
            if(info[i].fd == -1)
            {
                break; //这样就能把数组下标最小的fd找出来,并确保i指向它,直接break出去
            }
        }
        if(i == 256) //整个数组都被用完了,直接break出while循环
        {
            break;
        }
        // 主线程 - 等待接受连接请求
        info[i].fd = accept(lfd, (struct sockaddr*)&info[i].addr, &cli_len); //第二个参数是传出参数,
        //传出客户端ip信息(struct sockaddr*)类型

        // 创建子线程 - 通信
        pthread_create(&info[i].id, NULL, worker, &info[i]);
        // 设置线程分离 //这样子线程终止的时候会自动释放,就不需要主线程去释放了
        pthread_detach(info[i].id);
    }

    close(lfd);

    // 只退出主线程 //对子线程无影响,子线程可以继续通信
    pthread_exit(NULL);
    return 0;
}

5. 扩展:Socket API封装

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>

void perr_exit(const char *s)
{
        perror(s);
        exit(-1);
}

//也可以在vim下按2K跳转到man文档中的accept函数,因为man文档跳转不区分大小写
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
        int n;

again:
        if ((n = accept(fd, sa, salenptr)) < 0) 
    {
        //ECONNABORTED 发生在重传(一定次数)失败后,强制关闭套接字
        //EINTR 进程被信号中断 //如果accept函数在阻塞时被信号打断,处理完信号
           //返回时就不会在阻塞了,而是直接返回-1
        if ((errno == ECONNABORTED) || (errno == EINTR))
        {
        goto again; //如果accept阻塞时被信号打断了,需要在执行一次accept继续阻塞
        }
        else
        {
        perr_exit("accept error");
        }
        }
        return n;
}

int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

        if ((n = bind(fd, sa, salen)) < 0)
    {
        perr_exit("bind error");
    }

    return n;
}

int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;
    n = connect(fd, sa, salen);
        if (n < 0) 
    {
        perr_exit("connect error");
    }

    return n;
}

int Listen(int fd, int backlog)
{
    int n;

        if ((n = listen(fd, backlog)) < 0)
    {
        perr_exit("listen error");
    }

    return n;
}

int Socket(int family, int type, int protocol)
{
        int n;

        if ((n = socket(family, type, protocol)) < 0)
    {
        perr_exit("socket error");
    }

        return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
        ssize_t n;

again:
        if ( (n = read(fd, ptr, nbytes)) == -1) 
    {
        if (errno == EINTR)
                goto again; //如果read被信号中断了,应该让它继续去read等待读数据 (read阻塞时)
        else
                return -1;
        }

        return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
        ssize_t n;

again:
        if ((n = write(fd, ptr, nbytes)) == -1) 
    {
        if (errno == EINTR)
                goto again;
        else
                return -1;
        }
        return n;
}

int Close(int fd)
{
    int n;
        if ((n = close(fd)) == -1)
                perr_exit("close error");

    return n;
}

/*参三: 应该读取的字节数*/     //一直读到n字节数才会返回,否则阻塞等待                     
//socket 4096  readn(cfd, buf, 4096)   nleft = 4096-1500
ssize_t Readn(int fd, void *vptr, size_t n)
{
        size_t  nleft;              //usigned int 剩余未读取的字节数
        ssize_t nread;              //int 实际读到的字节数
        char   *ptr;

        ptr = vptr;
        nleft = n;                  //n 未读取字节数

        while (nleft > 0) 
    {
        if ((nread = read(fd, ptr, nleft)) < 0) 
        {
        if (errno == EINTR)
            {
        nread = 0;
            }
        else
            {
        return -1;
            }
        } 
        else if (nread == 0)
        {
        break;
        }

        nleft -= nread;   //nleft = nleft - nread 
        ptr += nread;
        }
        return n - nleft;
}

ssize_t Writen(int fd, const void *vptr, size_t n)
{
        size_t nleft;
        ssize_t nwritten;
        const char *ptr;

        ptr = vptr;
        nleft = n;
        while (nleft > 0) 
    {
        if ( (nwritten = write(fd, ptr, nleft)) <= 0) 
        {
        if (nwritten < 0 && errno == EINTR)
                nwritten = 0;
        else
                return -1;
        }
        nleft -= nwritten;
        ptr += nwritten;
        }
        return n;
}

static ssize_t my_read(int fd, char *ptr) //静态函数保证了读完第一个100字节才去读下一个100字节,而不是每次调用都读100字节
{
        static int read_cnt; //改变量存在静态数据区,下次调用my_read函数的时候,read_cnt会保留上次的值
        static char *read_ptr;
        static char read_buf[100];
        
        //因为这里的变量都是static的,所以并非每次调用my_read都会读100字节,而是读完100字节再去读下一个100字节
        if (read_cnt <= 0) { 
again:
        if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0)    //"hello\n"
        {
        if (errno == EINTR)
                goto again;
        return -1;
        } 
        else if (read_cnt == 0)
        return 0;

        read_ptr = read_buf;
        }
        read_cnt--; //在上次调用结束的值基础上--,保证了读完100字节再去读下一个100字节
        *ptr = *read_ptr++;

        return 1;
}

/*readline --- fgets*/    
//传出参数 vptr
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
        ssize_t n, rc;
        char    c, *ptr;
        ptr = vptr;

        for (n = 1; n < maxlen; n++) 
    {
        if ((rc = my_read(fd, &c)) == 1)    //ptr[] = hello\n
        {
        *ptr++ = c;
        if (c == '\n') //先读100个字节,依次遍历,遇到 '\n' 说明一行读完了
                break;
        } 
        else if (rc == 0) 
        {
        *ptr = 0;
        return n-1;
        } 
        else
        return -1;
        }
        *ptr = 0;

        return n;
}

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


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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

NPDP认证|2023年,0基础转行产品经理可以吗?

2023年&#xff0c;告别了疫情&#xff0c;各个行业正在快速回暖&#xff0c;很多企业都在高薪招聘产品经理岗位&#xff0c;这让很多其他岗位的朋友也想转行做产品经理&#xff0c;那没有基础&#xff0c;没有经验能转行做产品经理吗&#xff1f; 0基础转行产品经理是可能的&a…

Redis 删除策略

过期数据Redis中的数据特征 Redis是一种内存级数据库&#xff0c;所有数据均存放在内存中&#xff0c;内存中的数据可以通过TTL指令获取其状态XX &#xff1a;具有时效性的数据-1 &#xff1a;永久有效的数据-2 &#xff1a;已经过期的数据 或 被删除的数据 或 未定义的数据数…

Windows出现0xc00d36e5错误怎么办?

当我们使用Windows Media Player来播放视频文件时&#xff0c;可能会出现无法播放&#xff0c;并显示0xc00d36e5错误代码。该错误可能是因为Windows Media Player不支持视频格式、注册表项损坏、系统配置问题、第三方应用程序冲突等。下面将开始介绍0xc00d36e5错误的解决方法&a…

K_A12_014 基于STM32等单片机驱动S12SD紫外线传感器模块 串口与OLED0.96双显示

K_A12_014 基于STM32等单片机驱动S12SD紫外线传感器模块 串口与OLED0.96双显示一、资源说明二、基本参数参数引脚说明三、驱动说明IIC地址/采集通道选择/时序对应程序:数据对比&#xff1a;四、部分代码说明1、接线引脚定义1.1、STC89C52RCS12SD紫外线传感器模块1.2、STM32F103…

【数据结构】P0 三要素与五个特征

三要素与五个特征什么是数据结构数据结构的三要素逻辑结构存储结构数据的运算算法的五个特征时间复杂度什么是数据结构 数据元素之间存在着一种或者多种关系&#xff0c;这种关系称为结构。 数据结构的三要素 数据结构的三要素&#xff1a;逻辑结构、存储结构、数据的运算。 …

【面试题】手写防抖和节流

1. 手写防抖 debounce 首先介绍一个防抖的应用场景。假如需要监听一个输入框在输入文字后触发的change事件&#xff0c;那么通过keyup事件&#xff0c;每次输入文字后都会触发change事件&#xff0c;频繁触发的情况会影响系统的性能。因此可以使用防抖来降低触发频率&#xff…

flutter系列之:在flutter中使用导航Navigator

文章目录简介flutter中的NavigatorNavigator的使用总结简介 一个APP如果没有页面跳转那么是没有灵魂的&#xff0c;页面跳转的一个常用说法就是Navigator,flutter作为一个最为优秀的前端框架&#xff0c;Navigator肯定是必不可少的&#xff0c;那么在flutter中如何使用Navigat…

自建Git服务器

Gitea - Git with a cup of tea是一个国外团队基于国内一位大牛写的gogs开源项目&#xff08;Go语言开发&#xff09;二次开发的轻量Git社区&#xff0c;其稳定性非常好&#xff0c;而且是非常轻量级在个人亲测在1核1G的centos7主机上1个月不重启依然稳定运行&#xff0c;引用g…

chatgpt怎么去玩?解析各种用途和强大的功能

关于chatgpt怎么玩&#xff1f;他的一些原理以及玩法&#xff0c;相信大家都是挺好奇的吧&#xff0c;毕竟这个新的人工智能和以往我们玩过的&#xff0c;是完全不一样的&#xff0c;它具备更多的可玩性&#xff0c;而且具备有一定的学习能力&#xff0c;这就造就了它的强大&am…

记一次IDE的Docker插件实战(Dockfile篇)

IDEA下使用Docker插件制作镜像、推送及运行 前言 本部分主要根据IDEA的Docker插件实战(Dockerfile篇)_程序员欣宸的博客-CSDN博客_idea编写dockerfile一文所述内容进行实践&#xff0c;并对其中遇到的问题进行解答&#xff0c;从而串接多个知识点。 如何编写Dockfile 在Int…

【elasticsearch】elasticsearch es读写原理

一、前言&#xff1a; 今天来学习下 es 的写入原理。 Elasticsearch底层使用Lucene来实现doc的读写操作&#xff1a; Luence 存在的问题&#xff1a; 没有并发设计 lucene只是一个搜索引擎库&#xff0c;并没有涉及到分布式相关的设计&#xff0c;因此要想使用Lucene来处理海量…

「可信计算」与软件行为学

可信计算组织&#xff08;Ttrusted Computing Group,TCG&#xff09;是一个非盈利的工业标准组织&#xff0c;它的宗旨是加强在相异计算机平台上的计算环境的安全性。TCG于2003年春成立&#xff0c;并采纳了由可信计算平台联盟&#xff08;the Trusted Computing Platform Alli…

亮个相吧小宝贝儿,五款压箱底的软件

今天要给大家推荐5款压箱底的宝贝软件了&#xff0c;百度搜索一下就能找到下载链接了。 1.开源浏览器——Firefox Firefox是一个自由的&#xff0c;开放源码的浏览器&#xff0c;适用于 Windows, Linux 和 MacOS X平台&#xff0c;Mozilla Firefox官方版体积小速度快&#xf…

【项目】Vue3+TS CMS 登录模块搭建

&#x1f4ad;&#x1f4ad; ✨&#xff1a;Vue3 TS   &#x1f49f;&#xff1a;东非不开森的主页   &#x1f49c;: keep going&#x1f49c;&#x1f49c;   &#x1f338;: 如有错误或不足之处&#xff0c;希望可以指正&#xff0c;非常感谢&#x1f609;   Vue3TS一、…

微服务面试题:熔断和降级有什么区别?

文章目录引言1.概念不同1.1 熔断概念1.2 降级概念2.熔断器模型3.种状态之间的转换关系4.熔断策略5.熔断和降级的关系6.降级方式6.1、熔断降级&#xff08;不可用&#xff09;6.2、超时降级6.3、限流降级7.题外话8.总结引言 熔断和降级都是系统自我保护的一种机制&#xff0c;但…

进阶C语言 第四章-------《自定义类型》 (结构体、枚举、联合)知识点+完整思维导图+深入细节+通俗易懂+基本练习题+建议收藏

绪论 书接上回&#xff0c;通过上章的一些函数&#xff0c;我们可以让我们对于一些数值的调整有很大的帮助&#xff0c;本章自定义类型在C语言中同样也有着非常重要的地位&#xff0c;相信只要认真的阅读了本章&#xff0c;一定会对你有很大的帮助。 所以安全带系好&#xff0c…

使用Cmake从源码编译Lua

前置要求&#xff1a;电脑已经设置好了Cmake能够使用 首先下载Lua源码&#xff0c;文件后缀是tar.gz 各版本可以从这里找到&#xff1a;Lua - Version history 解压下载文件至所需目录&#xff0c;文件内容如下图&#xff1a; 解压即可。 在解压的文件夹&#xff08;本例是lua…

使用PyTorch-LSTM进行单变量时间序列预测的示例教程

时间序列是指在一段时间内发生的任何可量化的度量或事件。尽管这听起来微不足道&#xff0c;但几乎任何东西都可以被认为是时间序列。一个月里你每小时的平均心率&#xff0c;一年里一只股票的日收盘价&#xff0c;一年里某个城市每周发生的交通事故数。在任何一段时间段内记录…

Python控制本地浏览器并获取网页数据

1、前言 在自动化办公中&#xff0c;我们经常需要利用爬虫技能去批量获取网页的数据&#xff0c;但是有时候我们在利用爬虫的时候&#xff0c;会遇到一个问题&#xff0c;就是登录的时候要携带参数&#xff0c;不如账号、密码、其他的加密信息 就好比我现在公司&#xff0c;好…

JSP 质量管理系统myeclipse定制开发sqlserver数据库网页模式java编程jdbc

一、源码特点 JSP 质量管理系统是一套完善的web设计系统&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。开发环境为TOMCAT7.0,Myeclipse8.5开 发&#xff0c;数据库为SQLServer2008&#xff0c…