Linux c==网络编程、循环服务器、并发服务器、I/O多路转接 (23)

最新推荐文章于 2022-10-27 16:44:04 发布
最新推荐文章于 2022-10-27 16:44:04 发布
阅读量523 收藏
点赞数
分类专栏： Linux 文章标签： 网络编程 c语言 服务器 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weirdosick/article/details/53456629
版权

循环服务器

服务器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netdb.h>

#define PORT 3333
#define MAX_SIZE 1024

int main()
{
    int sockfd;
    int new_fd;

    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;

    int n_read;
    int ser_size;
    int opt = 1;

    char buffer[MAX_SIZE];

    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket error!\n");
    exit(1);
    }

    printf("socket success.............!\n");

    if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)) < 0)
    {
        perror("set socket option error!\n");
    exit(1);
    }

    bzero(&server_addr,0);
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("192.168.1.10"); 

    if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)
    {
        perror("bind error!\n");
    exit(1);
    }

    printf("bind success.............!\n");
    listen(sockfd,5);

    printf("listen success.............!\n");

    printf("accepting..................!\n");

    while(1)
    {
        ser_size = sizeof client_addr;

        if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,&ser_size)) < 0)
        {
            perror("accept error!\n");
        exit(1);
        }

        printf("accept success.................!\n");

    //read\recv

        printf("reading............!\n");
        n_read = read(new_fd,buffer,sizeof(buffer));

        if(n_read < 0)
        {
            perror("read client msg error!\n");
        exit(1);
        }

        buffer[n_read] = '\0';

        printf("recv msg = %s\n",buffer);
    }

    return 0;
}

客户端：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

#define PORT 3333
#define MAX_SIZE 1024

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("Please input server ip!\n");
    exit(1);
    }

    int sockfd;
    int n_write;

    struct sockaddr_in server_addr;

    char buffer[MAX_SIZE];

    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("client socket error!\n");
    exit(1);
    }

    bzero(&server_addr,0);

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)
    {
        perror("connect server error!\n");
    exit(1);
    }

    while(1)
    {
        memset(buffer,0,sizeof(buffer));
    printf("Please input send msg:\n");
        gets(buffer);

        n_write = write(sockfd,buffer,strlen(buffer));

    if(n_write == -1)
    {
        perror("send to server msg error!\n");
        exit(1);
    }
    }

    return 0;
}

缺点：只能接收到一个客户端，且等待其结束后才能接受下一个客户端

并发服务器：

服务器：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netdb.h>

#define PORT 3333
#define MAX_SIZE 1024

void * read_msg(void *arg)
{
    int n_read;

    int new_fd = *((int *)arg);

    char buffer[MAX_SIZE];

    printf("new_fd = %d\n",new_fd);

    while(1)
    {
        memset(buffer,0,sizeof(buffer));

    n_read = read(new_fd,buffer,sizeof(buffer));

    if(n_read < 0)
    {
        perror("recv client msg error!\n");
        exit(1);
    }

    if(n_read == 0)
    {
        printf("client is close!!\n");
        close(new_fd);
        pthread_exit(NULL);
    }

    buffer[n_read] = '\0';

    printf("recv msg:%s\n",buffer);
    }
}

int main()
{
    int sockfd;
    int new_fd;

    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;

    int n_read;
    int ser_size;
    int opt = 1;

    char buffer[MAX_SIZE];

    pthread_t id;

    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket error!\n");
    exit(1);
    }

    printf("socket success.............!\n");

    if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)) < 0)
    {
        perror("set socket option error!\n");
    exit(1);
    }

    bzero(&server_addr,0);
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("192.168.1.10"); 

    if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)
    {
        perror("bind error!\n");
    exit(1);
    }

    printf("bind success.............!\n");
    listen(sockfd,5);

    printf("listen success.............!\n");

    printf("accepting..................!\n");

    while(1)
    {
        ser_size = sizeof client_addr;

        if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,&ser_size)) < 0)
        {
            perror("accept error!\n");
        exit(1);
        }

        printf("accept success.................!\n");

    pthread_create(&id,NULL,read_msg,&new_fd);
    }

    return 0;
}

客户端：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

#define PORT 3333
#define MAX_SIZE 1024

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("Please input server ip!\n");
    exit(1);
    }

    int sockfd;
    int n_write;

    struct sockaddr_in server_addr;

    char buffer[MAX_SIZE];

    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("client socket error!\n");
    exit(1);
    }

    bzero(&server_addr,0);

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)
    {
        perror("connect server error!\n");
    exit(1);
    }

    while(1)
    {
        memset(buffer,0,sizeof(buffer));
    printf("Please input send msg:\n");
        gets(buffer);

        n_write = write(sockfd,buffer,strlen(buffer));

    if(n_write == -1)
    {
        perror("send to server msg error!\n");
        exit(1);
    }
    }

    return 0;
}

缺点：在客户端没有发送数据时，每个线程仍需轮流切换，浪费CPU资源

I/O多路转接：

服务器：

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

/* 宏定义端口号 */
#define portnumber 8000

#define MAX_LINE 80



int main(void)
{
    int  lfd;
    int cfd;
    int sfd;
    int rdy;

    struct sockaddr_in sin;
    struct sockaddr_in cin;

    int client[FD_SETSIZE];  /* 客户端连接的套接字描述符数组 */

    int maxi;
    int maxfd;                        /* 最大连接数 */

    fd_set rset;
    fd_set allset;

    socklen_t addr_len;         /* 地址结构长度 */

    char buffer[MAX_LINE];

    int i;
    int n;
    int len;
    int opt = 1;   /* 套接字选项 */

    char addr_p[20];



    /* 对server_addr_in  结构进行赋值  */
    bzero(&sin,sizeof(struct sockaddr_in));   /* 先清零 */
    sin.sin_family=AF_INET;                 //
    sin.sin_addr.s_addr=htonl(INADDR_ANY);  //表示接受任何ip地址   将ip地址转换成网络字节序
    sin.sin_port=htons(portnumber);         //将端口号转换成网络字节序

    /* 调用socket函数创建一个TCP协议套接口 */
    if((lfd=socket(AF_INET,SOCK_STREAM,0))==-1) // AF_INET:IPV4;SOCK_STREAM:TCP
    {
        fprintf(stderr,"Socket error:%s\n\a",strerror(errno));
        exit(1);
    }
    printf("socket!\n");

    /*设置套接字选项 使用默认选项*/
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    /* 调用bind函数 将serer_addr结构绑定到sockfd上  */
    if(bind(lfd,(struct sockaddr *)(&sin),sizeof(struct sockaddr))==-1)
    {
        fprintf(stderr,"Bind error:%s\n\a",strerror(errno));
        exit(1);
    }
    printf("bind!\n");

    /* 开始监听端口   等待客户的请求 */
    if(listen(lfd,20)==-1)
    {
        fprintf(stderr,"Listen error:%s\n\a",strerror(errno));
        exit(1);
    }
    printf("listen!\n");
    printf("Accepting connections .......\n");

    maxfd = lfd;                                /*对最大文件描述符进行初始化*/
    maxi = -1;

    /*初始化客户端连接描述符集合*/
    for(i = 0;i < FD_SETSIZE;i++)
    {
        client[i] = -1;
    }

    FD_ZERO(&allset);                     /* 清空文件描述符集合 */
    FD_SET(lfd,&allset);                    /* 将监听字设置在集合内 */


    /* 开始服务程序的死循环 */
    while(1)
    {
        rset = allset;
        printf("selecting!\n");
        /*得到当前可以读的文件描述符数*/
        rdy = select(maxfd + 1, &rset, NULL, NULL, NULL);

        printf("selected!\n");
        if(FD_ISSET(lfd, &rset))
        {

            addr_len = sizeof(sin);
            printf("accepting!\n");
            /* 接受客户端的请求 */
            if((cfd=accept(lfd,(struct sockaddr *)(&cin),&addr_len))==-1)
            {
                fprintf(stderr,"Accept error:%s\n\a",strerror(errno));
                exit(1);
            }
            printf("accepted!\n");


                     /*查找一个空闲位置*/
            for(i = 0; i<FD_SETSIZE; i++)
            {       //printf("%d\t",client[i]);
                if(client[i] <= 0)
                {
                    client[i] = cfd;   /* 将处理该客户端的连接套接字设置到该位置 */
                    break;
                }
            }

        /* 太多的客户端连接   服务器拒绝俄请求  跳出循环 */
            if(i == FD_SETSIZE)
            {
                printf("too many clients");
                exit(1);
            }

            FD_SET(cfd, &allset);     /* 设置连接集合 */

            if(cfd > maxfd)                  /* 新的连接描述符 */
            {
                maxfd = cfd;
            }

            if(i > maxi)
            {
                maxi = i;
            }

            if(--rdy <= 0)                /* 减少一个连接描述符 */
            {
                continue;
            }

        }

        /* 对每一个连接描述符做处理 */
        for(i = 0;i< FD_SETSIZE;i++)
        {
            if((sfd = client[i]) < 0)
            {
                continue;
            }

            if(FD_ISSET(sfd, &rset))
            {
                printf("reading!\n");
                n = read(sfd,buffer,MAX_LINE);
                printf("%s\n",buffer);
                printf("read!\n");
                if(n == 0)
                {
                    printf("the other side has been closed. \n");
                    fflush(stdout);                                    /* 刷新 输出终端 */
                    close(sfd);

                    FD_CLR(sfd, &allset);                        /*清空连接描述符数组*/
                    client[i] = -1;
                }

                else
                {
                    /* 将客户端地址转换成字符串 */
                    inet_ntop(AF_INET, &cin.sin_addr, addr_p, sizeof(addr_p));
                    addr_p[strlen(addr_p)] = '\0';

                    /*打印客户端地址 和 端口号*/
                    printf("Client Ip is %s, port is %d\n",addr_p,ntohs(cin.sin_port));


                    /* 谐函数出错 */
                    if(n == 1)
                    {
                        exit(1);
                    }
                }

                /*如果没有可以读的套接字   退出循环*/
                if(--rdy <= 0)
                {
                    break;


            }
        }

    }

    close(lfd);       /* 关闭链接套接字 */
    return 0;
}

客户端：

#include <stdlib.h> 
#include <stdio.h> 
#include <errno.h> 
#include <string.h> 
#include <netdb.h> 
#include <sys/types.h> 
#include <netinet/in.h> 
#include <sys/socket.h> 

#define portnumber 8000

int main(int argc, char *argv[]) 
{ 
    int nbytes;
    int sockfd; 
    char buffer[80]; 
    char buffer_2[80];
    struct sockaddr_in server_addr; 
    struct hostent *host; 

    if(argc!=2) 
    { 
        fprintf(stderr,"Usage:%s hostname \a\n",argv[0]); 
        exit(1); 
    } 

    if((host=gethostbyname(argv[1]))==NULL) 
    { 
        fprintf(stderr,"Gethostname error\n"); 
        exit(1); 
    } 

     /* 调用socket函数创建一个TCP协议套接口 */ 
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) // AF_INET:Internet;SOCK_STREAM:TCP
    { 
        fprintf(stderr,"Socket Error:%s\a\n",strerror(errno)); 
        exit(1); 
    } 


    bzero(&server_addr,sizeof(server_addr)); // 
    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(portnumber);
    server_addr.sin_addr = *((struct in_addr *)host->h_addr);//?


    if(connect(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1) 
    { 
        fprintf(stderr,"Connect Error:%s\a\n",strerror(errno)); 
        exit(1); 
    } 

    while(1){

    printf("Please input char:\n");


    fgets(buffer,1024,stdin); 
    write(sockfd,buffer,strlen(buffer));
       #if 1
    if((nbytes=read(sockfd,buffer_2,81))==-1) 
        { 
            fprintf(stderr,"Read Error:%s\n",strerror(errno));
            exit(1); 
        }

        buffer_2[nbytes]='\0';
        printf("Client received from Server %s\n",buffer_2);
        #endif


    }   
    close(sockfd);
    exit(0); 
}

优点：使用select来充当监管作用

焦糖饼干M
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux网络编程之循环服务器
02-18 1333
1.介绍 Linux网络循环服务器是指逐个处理客户端的连接，处理完一个连接后再处理下一个连接，是一个串行处理的方式，比较适合时间服务器，DHCP服务器.对于TCP服务器来说，主要阻塞在accept函数，等待客户端的连接。而对于UDP服务器来说，主要阻塞在recv函数. 2.循环服务器模型 TCP循环服务器: 算法如下:          socket(...);
Linux C 网络编程——5. 并发服务器
矩阵实验室
11-05 2471
1. 原理 在Linux C 网络编程——4. 简单TCP Socket程序中实现了一个最基本的基于TCP的CS通信， 这里介绍一种可以允许Server端可以同时处理多个请求（并发服务器）。 原理：每次accept服务器调用fork()，创建一个子进程处理请求。 2. 实现 只需要修改上一篇文章中的Server.c的while循环即可 while(1) { addr_
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
linux c 网络编程 并发
xiaopohaibebo的专栏
08-16 3843
[精华] Linux下各类TCP网络服务器的实现源代码 -------------------------------------------------------------------------------- http://www.chinaunix.net 作者:zhoulifa 发表于：2006-07-11 22:53:24 【发表评论】【查看原文】【Linux讨论区】【关闭】
linuxC 多线程并发服务器
w12563489的博客
09-26 328
linux c 多线程并发服务器
网络io与io多路复用select/poll/epoll 服务器并发代码实现
最新发布
08-29
网络I/O多路复用技术则是一种高效处理并发连接的方法，能够提高服务器性能，允许一个进程同时处理多个客户端请求。本文将深入探讨网络I/O的基本概念，以及select、poll和epoll这三种I/O多路复用机制，并通过实际代码...
Linux I/O多路复用详解及实例
09-15
Linux I/O多路复用是一种高效的编程模型，它允许单个进程同时监视多个I/O事件，从而提高了系统的并发处理能力。在Linux中，I/O多路复用主要有三种实现方式：`select`、`poll`和`epoll`。这些机制都用于解决传统阻塞I...
linux多进程和网络编程---ftp服务器实战
06-12
基于linux编程龙书，Apue和UNP深入浅出讲解原理: 文件读写效率，多进程与僵尸，信号合并，多线程读写锁同步，高并发服务端，select多路复用并以3000行ftp开源服务器剖析，巩固知识 linux基础编程linux网络编程ftp...
i/o多路复用实现的并发服务器
12-18
用selete实现的i/o多路复用并发服务器，socket，在linxu下实现
浅谈Linux 网络 I/O 模型简介（图文）
09-15
在I/O多路复用技术中，尤其是对于服务器端的网络编程，使用如`epoll`这样的机制可以在单线程下高效地处理多个客户端请求，减少线程管理和上下文切换的开销。Java网络编程中也有类似的概念，如BIO（ Blocking I/O）、...
linux c 多进程并发服务器
weixin_45715405的博客
11-08 477
文章目录1、流程2、代码 1、流程 需求：将客户端发送过来的数据，转换成大写，并将大写回过去 参考： Linux c socket套接字（看完测底明白六大函数使用） Linux c 通过信号回收N个子进程 1、socket 创建监听套接字 2、bind 绑定地址结构 3、lisen 链接上限 4、创建子进程 子进程： 4.1 关闭用于建立连接的文件描述符（使用不到） 4.2 读 4.3 将读到的内容改写成小写 4.4 写给客户端 4.5 循环此过程，当read读到的数据为0时
Linux网络编程服务器模型选择之循环服务器
weixin_30263073的博客
03-22 128
在网络程序里面，通常都是一个服务器处理多个客户机，为了出个多个客户机的请求，服务器端的程序有不同的处理方式。本节开始介绍Linux下套接字编程的服务器模型选择，主要包括循环服务器模型、并发服务器模型、IO复用服务器模型等，这也是我们常见的几种网络服务器模型。其中基本可以分为两大类， 1. 循环服务器：循环服务器在同一时刻只能响应一个客户端的请求，是比较简单的一种模型； 2. 并发服务...
Linux c 建立高并发服务器（select）实现
十四木的博客
08-21 970
什么是select，为什么要用select 我们前面介绍过如何使用多进程的方式实现服务器，使服务器能同时和多个客户端相连接，那我可不可以使用一个进程就解决这个问题，答案是肯定的。使用select的主旨就是不让应用程序自己去监视连接，取而代之的使用内核来监视。而且select具有跨平台性，是不是觉得立马高端了不少，但是select的缺点也很明显我们后面在谈。 select的各个参数 先来看看selet这个函数 ...
Linux （UDP和TCP）循环服务器
Travelerwz的博客
08-26 1063
Linux （UDP和TCP）循环服务器 参考：https://blog.csdn.net/tennysonsky/article/details/45671215 ​ 《unix网络编程》 按照处理方式分为：循环服务器和并发服务器 ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服务器在同一时刻可以响应多个客户端的请求 UDP循环服务器实现方法 U...
简单循环服务器
chenrang1850的博客
08-13 78
客户端部分： 比较简单 创建socket 然后connect服务器，进行通讯 发送数据，并且接收数据，然后关闭 服务器部分： 服务器要做的是创建socket，初始化地址信息，并且绑定socket，然后进行监听 然互就是在循环里处理客户端连接上来的请求，并且接...
TCP(循环服务器)---Linux
qq_52467056的博客
03-07 3198
一、模型 服务器模型可以分： 循环服务器：在同一时刻只能相应一个客户端的请求 并发服务器：在同一时刻可以相应多个客户端的请求 二、基础的TCP循环服务器 服务器端： #include <stdio.h> #include <sys/types.h> #include <stdlib.h> #include <sys/socket.h> #include <netinet/in.h> #include &...
循环服务器（关闭客户端而服务器能继续运行）
qq_50567183的博客
10-27 547
循环服务器（关闭客户端而服务器能继续运行）
[Linux网络编程] 循环服务器的实现
我的博客
11-17 1640
一、循环服务器的定义 循环服务器描述了在一个时刻只处理一个请求的服务器实现方式，通过在单线程内设置循环控制实现对多个客户端请求的逐一响应，这种服务器的设计、编程、调试和修改往往比较容易去实现。在循环执行的服务器对预期的负载能提供足够的反应速度时常使用这种类型的服务器。循环服务器有有UDP循环服务器和TCP循环服务器两种类型。 二、UDP循环服务器 UDP循环服务器的实现方法:UDP服务器每次
服务器编程模型 循环服务器->IO复用循环服务器 并发服务器->高性能并发服务器
晴天的专栏
08-17 1559
先说几个概念 循环服务器:循环服务器在同一个时刻只可以响应一个客户端的请求   并发服务器:并发服务器在同一个时刻可以响应多个客户端的请求 IIO复用循环服务器的概念前面那篇文章有 循环服务器分为两类:UDP循环服务器   ,TCP循环服务器 (IO复用循环服务器） 并发服务器也分为两类:UDP并发服务器，TCP并发服务器 其中TCP并发服务器又分三类:
Linux I/O 多路复用技术在并发服务器中的应用
这个课程内容旨在帮助学习者理解并掌握如何通过非阻塞I/O和I/O多路复用来构建更加高效和可靠的并发服务器，这对于信息安全和产品开发实践至关重要。通过这样的技术，开发者可以设计出能处理大量并发连接的服务器，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值