day10 socket编程高并发服务器

最新推荐文章于 2022-05-23 08:53:47 发布
最新推荐文章于 2022-05-23 08:53:47 发布
阅读量90 收藏
点赞数
原文链接：http://www.cnblogs.com/readlearn/p/10806481.html
版权

高并发服务器

这里写图片描述

多线程并发服务器

使用多进程并发服务器时要考虑以下几点：

  1. 父进程最大文件描述个数(父进程中需要close关闭accept返回的新文件描述符)
  2. 系统内创建进程个数(与内存大小相关)
  3. 进程创建过多是否降低整体服务性能(进程调度)
server.c
/* server.c */
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 800

void do_sigchild(int num)
{
    while (waitpid(0, NULL, WNOHANG) > 0)
        ;
}
int main(void)
{
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd, connfd;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];
    int i, n;
    pid_t pid;

    struct sigaction newact;
    newact.sa_handler = do_sigchild;
    sigemptyset(&newact.sa_mask);
    newact.sa_flags = 0;
    sigaction(SIGCHLD, &newact, NULL);

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);

    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    Listen(listenfd, 20);

    printf("Accepting connections ...\n");
    while (1) {
        cliaddr_len = sizeof(cliaddr);
        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

        pid = fork();
        if (pid == 0) {
            Close(listenfd);
            while (1) {
                n = Read(connfd, buf, MAXLINE);
                if (n == 0) {
                    printf("the other side has been closed.\n");
                    break;
                }
                printf("received from %s at PORT %d\n",
                        inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
                        ntohs(cliaddr.sin_port));
                for (i = 0; i < n; i++)
                    buf[i] = toupper(buf[i]);
                Write(connfd, buf, n);
            }
            Close(connfd);
            return 0;
        } else if (pid > 0) {
            Close(connfd);
        } else
            perr_exit("fork");
    }
    Close(listenfd);
    return 0;
}
client.c
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    int sockfd, n;

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
    servaddr.sin_port = htons(SERV_PORT);

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    while (fgets(buf, MAXLINE, stdin) != NULL) {
        Write(sockfd, buf, strlen(buf));
        n = Read(sockfd, buf, MAXLINE);
        if (n == 0) {
            printf("the other side has been closed.\n");
            break;
        } else
            Write(STDOUT_FILENO, buf, n);
    }
    Close(sockfd);
    return 0;
}

多线程并发服务器

在使用线程模型开发服务器时需考虑以下问题：

  1. 调整进程内最大文件描述符上限
  2. 线程如有共享数据，考虑线程同步
  3. 服务于客户端线程退出时，退出处理。（退出值，分离态）
  4. 系统负载，随着链接客户端增加，导致其它线程不能及时得到CPU
server.c
#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>

#include "wrap.h"

#define MAXLINE 8192
#define SERV_PORT 8000

struct s_info {                     //定义一个结构体, 将地址结构跟cfd捆绑
    struct sockaddr_in cliaddr;
    int connfd;
};

void *do_work(void *arg)
{
    int n,i;
    struct s_info *ts = (struct s_info*)arg;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];      //#define INET_ADDRSTRLEN 16  可用"[+d"查看

    while (1) {
        n = Read(ts->connfd, buf, MAXLINE);                     //读客户端
        if (n == 0) {
            printf("the client %d closed...\n", ts->connfd);
            break;                                              //跳出循环,关闭cfd
        }
        printf("received from %s at PORT %d\n",
                inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),
                ntohs((*ts).cliaddr.sin_port));                 //打印客户端信息(IP/PORT)

        for (i = 0; i < n; i++) 
            buf[i] = toupper(buf[i]);                           //小写-->大写

        Write(STDOUT_FILENO, buf, n);                           //写出至屏幕
        Write(ts->connfd, buf, n);                              //回写给客户端
    }
    Close(ts->connfd);

    return (void *)0;
}

int main(void)
{
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd, connfd;
    pthread_t tid;
    struct s_info ts[256];      //根据最大线程数创建结构体数组.
    int i = 0;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);                     //创建一个socket, 得到lfd

    bzero(&servaddr, sizeof(servaddr));                             //地址结构清零
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);                   //指定本地任意IP
    servaddr.sin_port = htons(SERV_PORT);                           //指定端口号 8000

    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)); //绑定

    Listen(listenfd, 128);      //设置同一时刻链接服务器上限数

    printf("Accepting client connect ...\n");

    while (1) {
        cliaddr_len = sizeof(cliaddr);
        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);   //阻塞监听客户端链接请求
        ts[i].cliaddr = cliaddr;
        ts[i].connfd = connfd;

        /* 达到线程最大数时，pthread_create出错处理, 增加服务器稳定性 */
        pthread_create(&tid, NULL, do_work, (void*)&ts[i]);
        pthread_detach(tid);                                                    //子线程分离,防止僵线程产生.
        i++;
    }

    return 0;
}
client.c
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    int sockfd, n;

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr.s_addr);
    servaddr.sin_port = htons(SERV_PORT);

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    while (fgets(buf, MAXLINE, stdin) != NULL) {
        Write(sockfd, buf, strlen(buf));
        n = Read(sockfd, buf, MAXLINE);
        if (n == 0)
            printf("the other side has been closed.\n");
        else
            Write(STDOUT_FILENO, buf, n);
    }

    Close(sockfd);

    return 0;
}
wrap.c
#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);
}

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
    int n;

again:
    if ((n = accept(fd, sa, salenptr)) < 0) {
        if ((errno == ECONNABORTED) || (errno == EINTR))
            goto again;
        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;

    if ((n = connect(fd, sa, salen)) < 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;
        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;
}

/*参三: 应该读取的字节数*/
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;

    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;
        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)
{
    static int read_cnt;
    static char *read_ptr;
    static char read_buf[100];

    if (read_cnt <= 0) {
again:
        if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
            if (errno == EINTR)
                goto again;
            return -1;
        } else if (read_cnt == 0)
            return 0;
        read_ptr = read_buf;
    }
    read_cnt--;
    *ptr = *read_ptr++;

    return 1;
}

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++ = c;
            if (c  == '\n')
                break;
        } else if (rc == 0) {
            *ptr = 0;
            return n - 1;
        } else
            return -1;
    }
    *ptr  = 0;

    return n;
}
wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_

void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);

#endif

转载于:https://www.cnblogs.com/readlearn/p/10806481.html

weixin_33796177
关注
【100天精通Python】Day46：Python网络编程_网络编程基础与入门
qq_35831906的博客
08-28 1365
网络编程是指利用计算机网络在不同计算机之间进行数据交换和通信的过程。它涵盖了多个层次，从底层的数据传输、协议交互到高层的应用程序开发。本文系统讲解网络编程基础与常用技术。
Java_Socket开发高并发小型服务器
10-20
该文档详细描述如何实现高并发编程和运用Socket编程 Socket原理、计算机工作机制、文档包含整个实例源码。详细介绍了整个项目流程
卷五：第1篇 高并发服务器开发-socket编程
qq_41659901的博客
05-23 344
目录 1.客户端和服务器通信流程 2.大端字节序、小端字节序 3.函数解析 4.系统调用函数 1.客户端和服务器通信流程 （1）客户端：创建socket、与服务器connect、read和write操作、关闭socket； （2）服务器：创建socket、bind（绑定协议、ip、端口）、listen（挂出信箱）、accept、 ead和write操作、关闭socket； 2.大端字节序、小端字节序 对于多字节数据： 4个字节：0X 12 ab， 大端字节序：低地址高字节、高地
Linux网络编程-网络基础-socket编程-高并发服务器
04-11
Linux网络编程-网络基础-socket编程-高并发服务器，非常详细的资料，值得你学习。
5高并发服务器：socket IPC
涂作权的博客
09-30 1617
socket IPC socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIX Domain Socket。虽然网络socket也可用于同一台主机的进程间通讯（通过loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算
黑马_Linux网络编程-网络基础-socket编程-高并发服务器
02-16
黑马程序员linux服务器开发网络编程配套文档，很好的参考资料
socket网络编程基础篇-------如何写一个简单的TCP服务器
vjhghjghj的博客
01-29 4636
目录 socket通信的预备知识 1.什么是socket通信？​ 2.什么是字节序？ 3.什么是IP地址转换？ 4.什么是网络地址格式？ ５．什么是“半关闭”？ 6.为什么会用到"半关闭"？ socket通信的具体过程 1.概述 2.socket函数 3.bind函数 4.listen函数，connect函数，accept函数 5.send函数，sendto函...
Linux下Socket编程
05-22
Linux下的Socket编程是开发网络应用程序的关键技术，它提供了一种标准接口，允许程序通过TCP/IP协议进行通信。Socket接口是TCP/IP网络编程的核心API，它最初在Unix操作系统中被引入，现在广泛应用于各种操作系统，...
day16_网络编程.zip
09-12
本主题将深入探讨“day16_网络编程”的核心概念、技术和实践应用。 网络编程涉及两个主要方面：客户端和服务器。客户端是发起连接请求的一方，而服务器则是接收并响应请求的一方。在“day16_网络编程”中，我们将...
day11_网络编程2
08-08
服务器需支持多用户并发访问。 在实际开发中，网络编程涉及的知识点广泛，包括网络模型（OSI七层模型或TCP/IP四层模型）、套接字编程、异常处理、数据编码解码、多线程编程等，这些都需要开发者深入理解和熟练掌握...
tcp socket实现单进程单线程 高并发服务端（c++源码）
11-22
tcp socket实现单进程单线程 高并发服务端源码 c++源码
Linux网络编程-网络基础-socket编程-高并发服务器.pdf
09-05
《Linux下C语言socket网络编程视频教程》对应文档 https://www.bilibili.com/video/BV1J4411j7Rx?p=19&spm_id_from=pageDriver
IOCPDemo_NET_.net高并发_并发_socket并发_.net_高并发_
10-04
C#高性能大容量SOCKET并发完成端口例子，里面包括有导出直接运行的例子，还有delphi版和C#.NET版的源码，对开发端口程序很有帮助。
C++线程池结合IOCP完成端口实现socket高并发服务端程序
02-22
C++线程池结合IOCP完成端口实现socket高并发服务端程序 包含mysql数据库操作、json数据解析
由浅入深，切身体会高并发socket java程序设计
godghkj的专栏
07-11 2365
首先，我并不是什么大神，我只是一个普普通通的码农而已，这里也不会涉及到代码层面的东西。 我所体会的只是我写程序的时候感受到的东西，并不代表真理。 这是一个针对入门菜鸟的文章，老鸟们欢迎挑刺。 起因是因为要做一个车载的GPS设备的平台，机器上传时通过socket来传输 ，我那个时候只是一个未毕业的还不是学计算机的孩子，做这个东西实在是难以下手的。 我想到用是java，为什么？那时候的我，认为
【Socket编程】篇四之并发服务器
mick_seu的博客
05-24 928
前三章中，服务器端一次只能处理一个客户，当多个客户端连接几乎同时到达服务端时，系统内核将其排入队列，accept函数依次处理连接，那么如何使得服务器端能够同时服务于多个客户呢？多进程编程 并发服务器最简单的实现方法就是使用fork函数为每个客户端创建各自进程。 并发服务器的框架如下： server_socket = socket() bind(server_socket,... )
实现socket并发的几种方法
weixin_30340617的博客
03-04 643
# 使用多进程实现socket聊天并发-server #服务端 import socket from multiprocessing import Process def server(conn,addr): while True: try: msg=conn.recv(1024) conn....
高并发基础之Socket入门
Android_la的博客
06-20 388
文章目录1 问题背景2 什么是Socket3 Socket 1 问题背景 毕业设计做高并发相关的研究，前面粗略研究了解决高并发的核心——LinuxIO模型，笔者认为需要再粗略研究Socket相关的问题。 参考自：Socket技术详解（看清Socket编程） 2 什么是Socket 计算机之间通信需要知道对方的地址，Socket就是存储这个地址，实质上Socket是IP加端口号，格式是xx.xx.xx.xx:xxxx。如下图所示： 3 Socket ...
VC++与MFC基础：Socket编程入门教程
教程特别关注了Socket的创建，讲解了如何在vc++中使用MFC进行Socket编程。" 在MFC和vc++的编程环境中，Socket的创建是网络编程的基础。创建Socket的过程包括构造Socket对象和调用Create函数。在描述中提到，Create...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值