linux网络编程echo多进程服务器

最新推荐文章于 2019-03-15 08:16:21 发布
最新推荐文章于 2019-03-15 08:16:21 发布
阅读量152 收藏 3
点赞数
原文链接：http://www.cnblogs.com/peixiguang/p/6035215.html
版权

echo_server 多进程版本

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <memory.h>
#include <signal.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
int sockfd;

void sign_handler(int signo)
{
    pid_t pid;
    int stat;
    if(signo==SIGINT)
    {
        printf("echo server close\n");
        close(sockfd);
        exit(1);
    }
    if(signo==SIGCHLD){
        while((pid=waitpid(-1,&stat,WNOHANG))>0){
            printf("child %d closed\n",pid);
        }
    }
    return ;
}
void out_fd(int fd)
{
    struct sockaddr_in arr;
    socklen_t len=sizeof(arr);
    if(getpeername(fd,(struct sockaddr*)&arr,&len)<0){
        perror("getpeername fail\n");
        exit(1);
    }
    char ip[16];
    memset(&ip,0,sizeof(ip));
    inet_ntop(AF_INET,&arr.sin_addr.s_addr,ip,sizeof(ip));
    printf("%s connected\n",ip);
}
void server_do(int fd)
{
    char buffer[BUFSIZ];
    while(1){
        printf("ready to read\n");
        memset(buffer,0,sizeof(buffer));
        ssize_t size;
        if((size=read(fd,buffer,sizeof(buffer)))<0){
            perror("server child read fail\n");
            break;
        }else if(size==0){
            break;
        }else{
            printf("number of received bytes=%ld\n",size);
            buffer[size-1]='\0';
            printf("%s\n",buffer);
            if(write(fd,buffer,size)<0){
                if(errno==EPIPE){
                    break;
                }
                perror("server child write fail\n");
            }
        }
    }
}
int main(int argc,char *argv[])
{
    int fd;
    pid_t pid;
    if(argc<2)
    {
        printf("usage:%s <port>",argv[0]);
        exit(1);
    }
    //注册信号
    if(signal(SIGINT,sign_handler)==SIG_ERR){
        perror("signal sigint error\n");
        exit(1);
    }
    if(signal(SIGCHLD,sign_handler)==SIG_ERR){
        perror("signal sigint error\n");
        exit(1);
    }
    /*create socket*/
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0){
        perror("socket create fail\n");
        exit(1);
    }
    /*bind socket*/
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_port=htons(atoi(argv[1]));
    serveraddr.sin_addr.s_addr=INADDR_ANY;
    if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){
        perror("socket bind fail\n");
        exit(1);
    } 
    if(listen(sockfd,10)<0){
        perror("socket listen fail\n");
        exit(1);
    }
    /*accept*/
    while(1){
        if((fd=accept(sockfd,NULL,NULL))<0){
            if(errno==EINTR){
                continue;
            }
            perror("socket accept fail\n");
        }
        pid_t pid=fork();
        if((pid=fork())<0){
            perror("fork fail\n");
            continue;
        }else if(pid==0){
            close(sockfd);
            out_fd(fd);
            server_do(fd);
            exit(0);
        }
        close(fd);
    }
    return 0;
}

echo_client

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <memory.h>
#include <signal.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int sockfd;

void cli_do(int sockfd)
{

/*双向通信*/    char buffer[BUFSIZ];
    char *promat=">";
    size_t size;
    while(1){
        memset(buffer,0,sizeof(buffer)); write(STDOUT_FILENO,promat,1); if((size=read(STDIN_FILENO,buffer,sizeof(buffer))>0){ if(size<0) continue; buffer[size-1]='\0';
 }else if(size==0){
　　　　　　　continue;
　　　　 } if(write(sockfd,buffer,size)>0){ if(read(sockfd,buffer,sizeof(buffer))>0){ printf("%s\n",buffer); } } }
}
int main(int argc,char *argv[])
{
    if(argc<3){
        printf("usage:%s <ip><port>",argv[0]);
        exit(1);
    }
    /*create socket*/
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0){
        perror("socket create fail\n");
    }
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_port=htons(atoi(argv[2]));
    inet_pton(AF_INET,argv[1],&serveraddr.sin_addr.s_addr);
    if(connect(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){
        perror("server connect fail\n");
        exit(1);
    }
    cli_do(sockfd);
    close(sockfd);
    return 0;
}

 echo客户机改进：

客户机read阻塞与stdin时，如果此时服务器断开连接,服务器给客户机发送一个FIN,但是客户机此时阻塞与标准输入，它将看不到这个EOF

所以进程需要一个预先告知内核能力，使得内核一旦发现进程指定一个或者多个I/O条件就绪 ，它就通知进程，这个能力称为I/O多路复用

所以客户端cli_do改用select方式

cli_do修订

void cli_do(int sockfd)
{
    char buffer[BUFSIZ];
    char *promat=">";
    size_t size;
    fd_set rset;
    FD_ZERO(&rset);
    while(1){
        //select系统调用设置
        FD_SET(sockfd,&rset);
        FD_SET(STDIN_FILENO,&rset);
        //设置select就绪事件 
        if(select(sockfd+1,&rset,NULL,NULL,NULL)<0){
            perror("select close\n");
            break;
        }
        if(FD_ISSET(STDIN_FILENO,&rset)){/*input is readable*/
            if((size=read(STDIN_FILENO,buffer,sizeof(buffer))>0{
               buffer[size-1]='\0';
　　　　　　  }
write(sockfd,buffer,size)
        }
        if(FD_ISSET(sockfd,&rset)){/*socket is readable*/
            if((size=read(sockfd,buffer,sizeof(buffer))==0){//服务端发送FIN过来
                perror("server connect close\n");
                break;
            }else{
                printf("%s\n",buffer);
            }
        }
    }
}

 echo客户端改进：

这种客户端--服务端   应-答  模式全双工管道数据并没有写满，存在空间的极大浪费

我们改用 批量输入-批量应答  模式

使用select 和shutdown 函数，前者能接收到服务器关闭时的通知，后者运行我们批量输入

cli_do修订

 

void cli_do(int sockfd)
{
    int stdineof;
    char buffer[BUFSIZ];
    char *promat=">";
    size_t size;
    fd_set rset;
    
    FD_ZERO(&rset);
    stdineof=0;
    while(1){
        write(STDOUT_FILENO,promat,1);
        //select系统调用设置
        FD_SET(sockfd,&rset);
        if(stdineof==0) FD_SET(STDIN_FILENO,&rset);
        //设置select就绪事件 
        if(select(sockfd+1,&rset,NULL,NULL,NULL)<0){
            perror("select close\n");
            break;
        }
        if(FD_ISSET(STDIN_FILENO,&rset)){/*input is readable*/
            if((size=read(STDIN_FILENO,buffer,sizeof(buffer)))==0){
                stdineof=1;
                shutdown(sockfd,SHUT_WR);/*send FIN*/
                FD_CLR(STDIN_FILENO,&rset);
                continue;
            }
            buffer[size-1]='\0';
            write(sockfd,buffer,size);
        }
        if(FD_ISSET(sockfd,&rset)){/*socket is readable*/
            if((size=read(sockfd,buffer,sizeof(buffer)))==0){
                if(stdineof==1){
                    return;
                }else{
                    perror("server terminated prematurely\n");
　　　　　　　　　　　 break;
                }
            }
            printf("%s\n",buffer);
        }
    }
}

 使用I/O复用模型  单进程 select 就绪事件监听描述符集 修改echo_server

echo_server 修订版

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <memory.h>
#include <signal.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <sys/select.h>
int sockfd;

void sign_handler(int signo)
{
    pid_t pid;
    int stat;
    if(signo==SIGINT)
    {
        printf("echo server close\n");
        close(sockfd);
        exit(1);
    }
    if(signo==SIGCHLD){
        printf("client close\n");
        wait(0);
    }
    return ;
}
void out_fd(int fd)
{
    struct sockaddr_in arr;
    socklen_t len=sizeof(arr);
    if(getpeername(fd,(struct sockaddr*)&arr,&len)<0){
        perror("getpeername fail\n");
        exit(1);
    }
    char ip[16];
    memset(&ip,0,sizeof(ip));
    inet_ntop(AF_INET,&arr.sin_addr.s_addr,ip,sizeof(ip));
    printf("%s connected\n",ip);
}

int main(int argc,char *argv[])
{
    int fd;
    pid_t pid;
    if(argc<2)
    {
        printf("usage:%s <port>",argv[0]);
        exit(1);
    }
    //注册信号
    if(signal(SIGINT,sign_handler)==SIG_ERR){
        perror("signal sigint error\n");
        exit(1);
    }
    if(signal(SIGCHLD,sign_handler)==SIG_ERR){
        perror("signal sigint error\n");
        exit(1);
    }
    /*create socket*/
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0){
        perror("socket create fail\n");
        exit(1);
    }
    /*bind socket*/
    struct sockaddr_in serveraddr,cliaddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_port=htons(atoi(argv[1]));
    serveraddr.sin_addr.s_addr=INADDR_ANY;
    if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){
        perror("socket bind fail\n");
        exit(1);
    } 
    if(listen(sockfd,10)<0){
        perror("socket listen fail\n");
        exit(1);
    }
    /*accept*/
    int i,maxfd,maxi,connfd,clientfd;
    int nready,client[FD_SETSIZE];
    ssize_t size;
    fd_set rset,allset;
    char buffer[BUFSIZ];
    socklen_t clien;

    maxfd=sockfd;
    maxi=-1;/*index into client[] array*/
    for(i=0;i<FD_SETSIZE;i++){
        client[i]=-1;
    }
    FD_ZERO(&allset);
    FD_SET(sockfd,&allset);
    for(;;){
        rset=allset;
        nready=select(maxfd+1,&rset,NULL,NULL,NULL);
        
        if(FD_ISSET(sockfd,&rset)){/*new client connection*/
            clien=sizeof(cliaddr);
            if((connfd=accept(sockfd,(struct sockaddr*)&cliaddr,&clien))>0){
                out_fd(connfd);
            }
            for(i=0;i<FD_SETSIZE;i++){
                if(client[i]<0){
                    client[i]=connfd;
                    break;
                }
            }
            if(i==FD_SETSIZE){
                perror("too many clients\n");
            }
            FD_SET(connfd,&allset);//添加新的监听就绪事件
            if(connfd>maxfd) maxfd=connfd;
            if(i>maxi) maxi=i; 
            if(--nready<=0) continue;
        }
        for(i=0;i<=maxi;i++){/*check all clients for data*/
            if((clientfd=client[i])<0) continue;
            if(FD_ISSET(clientfd,&rset)){
                printf("ready to read\n");
                if((size=read(clientfd,buffer,sizeof(buffer)))==0){//接受到EOF，client已经关闭
                    close(clientfd);
                    FD_CLR(clientfd,&allset); 
                    client[i]=-1;
                }else{
                    printf("%s\n",buffer);
                    write(clientfd,buffer,size);
                    if(--nready<=0) break;
                }
            }

        }
    }
}

 poll系统调用

void cli_do(int sockfd)
{
    int stdineof;
    char buffer[BUFSIZ];
    char *promat=">";
    size_t size;
    fd_set rset;
    
    FD_ZERO(&rset);
    stdineof=0;
    while(1){
        write(STDOUT_FILENO,promat,1);
        //select系统调用设置
        FD_SET(sockfd,&rset);
        if(stdineof==0) FD_SET(STDIN_FILENO,&rset);
        //设置select就绪事件 
        if(select(sockfd+1,&rset,NULL,NULL,NULL)<0){
            perror("select close\n");
            break;
        }
        if(FD_ISSET(STDIN_FILENO,&rset)){/*input is readable*/
            if((size=read(STDIN_FILENO,buffer,sizeof(buffer)))==0){
                stdineof=1;
                shutdown(sockfd,SHUT_WR);/*send FIN*/
                FD_CLR(STDIN_FILENO,&rset);
                continue;
            }
            buffer[size-1]='\0';
            write(sockfd,buffer,size);
        }
        if(FD_ISSET(sockfd,&rset)){/*socket is readable*/
            if((size=read(sockfd,buffer,sizeof(buffer)))==0){
                if(stdineof==1){
                    return;
                }else{
                    perror("server terminated prematurely\n");
                    break;
                }
            }
            printf("%s\n",buffer);
        }
    }
}

echo_server

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

int sockfd;

void sign_handler(int signo)
{
    pid_t pid;
    int stat;
    if(signo==SIGINT)
    {
        printf("echo server close\n");
        close(sockfd);
        exit(1);
    }
    if(signo==SIGCHLD){
        printf("client close\n");
        wait(0);
    }
    return;
}
void out_fd(int fd)
{
    struct sockaddr_in arr;
    socklen_t len=sizeof(arr);
    if(getpeername(fd,(struct sockaddr*)&arr,&len)<0){
        perror("getpeername fail\n");
        exit(1);
    }
    char ip[16];
    
    memset(&ip,0,sizeof(ip));
    inet_ntop(AF_INET,&arr.sin_addr.s_addr,ip,sizeof(ip));
    printf("%s connected\n",ip);
}

int main(int argc,char *argv[])
{
    printf("tsest");
    
    if(argc<2)
    {
        printf("usage:%s <port>",argv[0]);
        exit(1);
    }
    //注册信号
    if(signal(SIGINT,sign_handler)==SIG_ERR){
        perror("signal sigint error\n");
        exit(1);
    }
    if(signal(SIGCHLD,sign_handler)==SIG_ERR){
        perror("signal sigint error\n");
        exit(1);
    }
    /*create socket*/
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0){
        perror("socket create fail\n");
        exit(1);
    }
    /*bind socket*/
    struct sockaddr_in serveraddr,cliaddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_port=htons(atoi(argv[1]));
    serveraddr.sin_addr.s_addr=INADDR_ANY;
    if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){
        perror("socket bind fail\n");
        exit(1);
    } 
    if(listen(sockfd,10)<0){
        perror("socket listen fail\n");
        exit(1);
    }    
    /*poll系统调用*/
    int i,maxfd,maxi,connfd,clientfd,nready,open_max;
    ssize_t size;
    char buffer[BUFSIZ];
    socklen_t clien;
    open_max=sysconf(_SC_OPEN_MAX);
    
    struct pollfd client[open_max];
    client[0].fd=sockfd;
    client[0].events=POLLRDNORM;
    for(i=0;i<open_max;i++) client[i].fd=-1;
    maxi=0;
 
    for(;;){
        nready=poll(client,maxi+1,0);
        
        if(client[0].revents & POLLRDNORM){/*new client connection*/
            printf("werwerew");
            break;
            clien=sizeof(cliaddr);
            if((connfd=accept(sockfd,(struct sockaddr*)&cliaddr,&clien))>0) out_fd(connfd);
            
            for(i=0;i<open_max;i++){
                if(client[i].fd<0){
                    client[i].fd=connfd;
                    break;
                }
            }
            if(i==open_max) perror("too many clients\n");
            client[i].events=POLLRDNORM;//添加新的监听就绪事件
            if(i>maxi) maxi=i; 
            if(--nready<=0) continue;
        }
        for(i=0;i<=maxi;i++){/*check all clients for data*/
            if((clientfd=client[i].fd)<0) continue;
            if(client[i].revents&(POLLRDNORM|POLLERR)){
                printf("ready to read\n");
                break;
                if((size=read(clientfd,buffer,sizeof(buffer)))==0){//接受到EOF，client已经关闭
                    close(clientfd); 
                    client[i].fd=-1;
                }else{
                    printf("%s\n",buffer);
                    write(clientfd,buffer,size);
                    if(--nready<=0) break;
                }
            }

        }
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/peixiguang/p/6035215.html

dengji6074
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux echo服务客户端与服务器端程序
11-26
linux echo服务客户端与服务器端程序
Unix/Linux编程：并发的、面向连接的(TCP)服务器-----多进程版(ECHO)
OceanStar的博客
06-09 888
引言 本文将构造并发服务器所使用的算法如下： 主1：创建套接字并将其绑定到它所提供服务的熟知端口上，让该套接字保持无连接的 主2：将该端口设置为被动模式，使其准备为服务器所用 主3：反复调用accept以便接收来自客户的下一个连接请求，并创建新的从线程或者进程来处理响应 从1：从主线程传递来的连接请求(即针对连接的套接字)开始 从2：用该连接与客户进行交互：读取请求并发回响应 从3：关闭连接并退出。在处理完客户的所有请求后，从线程退出 服务器计算响应时，服务器依赖操作系统对并发处理的支持来达
Windows平台基于多进程的echo服务器简单实现
Shilyx的C/C++专栏
08-04 1884
这里的Echo服务器就是说客户端发什么，服务器端立刻返回什么。一种常见的实现是基于多线程的，在linux上还很容易就用fork实现一个多进程的服务器。 下面演示一下在Windows平台如何用多进程来实现一个echo服务器。 /* * @file : TestEchoServerMultiProcess.cpp * @author: Shilyx * @date : 20
Linux 并发echo服务器之多进程
xl十一的博客
11-03 907
流程 创建套接字：s 设置地址并绑定 监听 while [1] 接收连接：c [2] 创建子进程 [3] 父进程：close© [4] 子进程： close(s) Chat© close© exit(0) [5] Chat© while: recv send close(s) Code #include &amp;lt;iostream&amp;gt; #include &amp;lt;unistd.h&amp;gt; #...
利用套接字实现进程通信一例
weixin_34040079的博客
03-12 203
下面程序实现的功能是：客户端将从键盘输入的内容发送给服务器，然后服务器在将受到的数据原封不动的发给客户端。   先看看服务器端的程序： 1: /* 2: * ===================================================================================== 3: * 4: ...
Linux网络编程使用多进程实现服务器并发访问.docx
09-26
以下是一个简单的多进程服务器实现示例： ```c #include #include #include #include #include #include #include #include #include #define SERV_PORT 1113 #define LISTENQ 32 #define MAXLINE 1024 ...
多进程服务器端全部程序
02-06
在IT行业中，网络编程是构建分布式系统和网络应用程序的基础，其中多进程服务器端程序是实现高并发、高性能服务的关键技术之一。本项目“多进程服务器端全部程序”聚焦于利用多进程模型来设计和实现一个服务器端应用...
Linux下实现PHP多进程的方法分享
10-27
在Linux环境下，PHP可以通过Process Control Functions (PCNTL) 扩展来实现多进程编程，这对于需要并发执行任务或者分布式处理大数据的场景非常有用。PCNTL是PHP提供的一组函数，专门用于处理多进程控制，它允许我们...
PHP多进程编程总结(推荐)
12-19
多进程编程的一个常见用途是实现并发处理，例如在Web服务器中处理大量请求或在后台执行耗时的操作。通过创建子进程，每个子进程可以并行执行任务，提高程序的执行效率。然而，需要注意的是，多进程间的通信和同步...
Linux系统编程-进程.docx
11-10
总的来说，理解Linux系统编程中的进程概念，包括其生命周期、并发执行机制、CPU和MMU的作用、PCB的结构以及环境变量的使用，对于深入学习Linux服务器开发和系统编程至关重要。这些知识将帮助开发者更好地控制和管理...
基于多进程的并发回声服务器端的实现
DG
09-27 1389
服务器按处理方式可以分为迭代服务器和并发服务器两类。 简单Socket客户端服务器通信，服务器每次只能处理一个客户的请求，实现简单但效率很低，通常这种服务器被称为迭代服务器。 一个服务器具有同时处理多个客户请求的能力，其效率很高却实现复杂，这种称为并发服务器，在实际应用中，并发服务器应用的最广泛。 Linux有3种实现并发服务器的方式：多进程并发服务器，多线程并发服务器，IO复用。  ...
简单的echo服务器程序
sunnyyouknow的专栏
08-29 818
#include #include #include #include #include #include #include #include #define SERVERIP "192.168.1.193" #define SERVERPORT 12345 #define MAXBUFFER 256 int main(int argc, char** argv) { i
Linux系统基于TCP的回声（echo）服务器端/客户端（改写）
weixin_42276966的博客
03-15 2016
服务端是一个选代服务端，持续提供服务，同时只能为一个客户端提供服务。 信息传输协议(V2.0)：1字节字符串长度+字符串内容(长度小于255) 信息传输协议(V3.0)：4字节字符串长度+字符串内容(长度小于2^32) 服务器端： #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include &amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #include &amp;amp;amp
网络编程之并发-多进程
左霖风的博客
12-29 579
我们现实生活中，用到的服务器都是可以同时处理多个客户端的请求， 称这种服务器为并发服务器 实现并发服务器的方法有三种：  多进程：创建多个进程提供服务 多路复用：捆绑并统一管理I/O对象 多线程：生成与客户端等量的线程       1.首先说说进程：               进程：占用内存空间的正在运行的程序          一般来说，CPU核的个数与可同时运行的进程数相同，如果进程数超过C...
《TCP/IP网络编程》第 10 章 多进程服务器端 笔记
riba2534的博客
01-21 653
第 10 章 多进程服务器端 本章代码，在TCP-IP-NetworkNote中可以找到。 10.1 进程概念及应用 10.1.1 并发服务端的实现方法 通过改进服务端，使其同时向所有发起请求的客户端提供服务，以提高平均满意度。而且，网络程序中数据通信时间比 CPU 运算时间占比更大，因此，向多个客户端提供服务是一种有效的利用 CPU 的方式。接下来讨论同时向多个客户端提供服务的并发服务器端。下面...
mpu6050陀螺仪使用方法开发教程文档.docx
07-30
mpu6050陀螺仪使用方法
【SCI顶级】龙格库塔算法RUN-CNN-LSTM-Multihead-Attention温度预测【含源码 5747期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Mutilhead-Attention回归预测
大模型的数学之魂：统计学习理论精要
07-30
大型机器学习模型，通常简称为“大模型”，是指具有数十亿甚至数千亿参数的深度神经网络模型。这些模型因为其庞大的参数量和复杂的计算结构，能够处理非常复杂的任务和数据，展现出强大的表达能力和预测性能。大模型在自然语言处理、计算机视觉、语音识别和推荐系统等多个领域都有广泛的应用。 大模型的设计目的是通过训练海量数据来学习复杂的模式和特征，从而具备强大的泛化能力，能够对未见过的数据做出准确的预测。与参数较少、层数较浅的小模型相比，大模型虽然需要更多的计算资源和时间来训练和推理，但它们展现出了一种被称为“涌现能力”的特性，即从原始训练数据中自动学习并发现新的、更高层次的特征和模式。 大模型的发展历程可以分为几个阶段，从早期的卷积神经网络模型发展到以Transformer为代表的全新神经网络模型，再到当前以GPT为代表的预训练大模型阶段。Transformer架构因其自注意力机制而成为大模型的核心技术，它使得模型能够更好地理解和处理文本数据中的长距离依赖关系。 大模型的分类主要包括语言大模型（NLP）、视觉大模型（CV）和多模态大模型。语言大模型专注于处理文本数据和理解自然语言，而视觉大模型用
唯美淡雅四页.zip
最新发布
07-30
【简历模板】工作总结、商业计划书、述职报告、读书分享、家长会、主题班会、端午节、期末、夏至、中国风、卡通、小清新、岗位竞聘、公司介绍、读书分享、安全教育、文明礼仪、儿童故事、绘本、防溺水、夏季安全、科技风、商务、炫酷、企业培训、自我介绍、产品介绍、师德师风、班主任培训、神话故事、巴黎奥运会、世界献血者日、防范非法集资、3D快闪、毛玻璃、人工智能等等各种样式的ppt素材风格。 设计模板、图片素材、PPT模板、视频素材、办公文档、小报模板、表格模板、音效配乐、字体库。 广告设计：海报，易拉宝，展板，宣传单，宣传栏，画册，邀请函，优惠券，贺卡，文化墙，标语，制度，名片，舞台背景，广告牌，证书，明信片，菜单，折页，封面，节目单，门头，美陈，拱门，展架等。 电商设计：主图，直通车，详情页，PC端首页，移动端首页，钻展，优惠券，促销标签，店招，店铺公告等。 图片素材：PNG素材，背景素材，矢量素材，插画，元素，艺术字，UI设计等。 视频素材：AE模板，会声会影，PR模板，视频背景，实拍短片，音效配乐。 办公文档：工作汇报，毕业答辩，企业介绍，总结计划，教学课件，求职简历等PPT/WORD模板。
使用muduo库的Linux多线程TCP服务器编程实战
"本书主要介绍如何使用muduo C++网络库进行Linux多线程服务端编程，由陈硕撰写，旨在展示在多核时代利用现代C++编写高性能TCP网络服务器的方法。书中聚焦于‘one loop per thread’的编程模型，这是一种在Linux环境...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值