Linux系统的服务器并发编程

最新推荐文章于 2024-06-03 17:02:17 发布
最新推荐文章于 2024-06-03 17:02:17 发布
阅读量660 收藏 2
点赞数
分类专栏： 嵌入式编程 文章标签： 多路复用 Linux系统 服务器的并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42249237/article/details/82022912
版权

在网络通信中，大部分情况都会使用TCP协议的网络通信方式，毕竟TCP协议的通信方式安全性高、数据不易丢失、还能远距离传输数据。但TCP协议并不能像UDP协议一样本身就具有并发特性，所以在编写TCP协议网络通信中，通常采用多路复用和多线程/多进程的方式实现服务器的并发，即一个服务器同时服务多个客户端。

多路复用

多路复用的相关函数会在程序中有注释。实现多路复用的程序如下：
头文件com.h

#ifndef     TCP_STRUCT_TEST_H
#define     TCP_STRUCT_TEST_H
#define SERV_PORT  8900
/*网络中绝不发送浮点型数据
*/
struct msg_struct {
    char msgtype;
    int temp;
    int humidty;
    short cnt;
    char des[64];
} __attribute__((packed));      /*告诉编译器, 不要对该结构进行任何优化 取消对齐*/
#endif

服务器程序server.h


#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include "comm.h"
/*
多路复用的实现：用函数select
    int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
    注：fd是文件描述符，是socket、accept函数的返回值
        nfds:所有fd中数字最大的那个+1         
        readfds:读文件的集合。如果你关注某个文件/socket为可读事件,将其加入该集合
        writefds:写文件的集合。如果你关注某个文件/socket为可写事件,将其加入该集合
        exceptfds:异常的集合。如果你关注某个文件/socket为异常事件,将其加入该集合
    注意：集合是双向的参数, 你在调用之前将需要监控的fd加入set，当select返回的时候, 里面的原始数据被抹掉.只保留了发生事件的fd。
        timeout:超时时间
            当所监控的fd集合,超过一定的时间，仍然没有任何fd发生事件也退出
            NULL:永久等待
            timeout.sec=timeout.usec=0,表示非阻塞监控
            timeout.sec = 5;指定超时时间
        返回值:
            -1:失败，并设置errno的值
            >0:表示发生事件fd的个数
            ==0:没有fd发生事件, 超时了 
    void FD_CLR(int fd, fd_set *set);       //将fd从set中踢掉
    int  FD_ISSET(int fd, fd_set *set);     //判断fd是否在set中
    void FD_SET(int fd, fd_set *set);       //将fd加入到set中去
    void FD_ZERO(fd_set *set);              //清空set
*/
/*  监控的读集合  */
fd_set  readfdset;
fd_set  readfdset_backup;
int max;
int socket_fds[64];
int socket_top  = 0;
int serv_do_client_something(int socket_client)//事件发生后要执行的事情
{
    int ret;
    struct msg_struct msg_serv;
    memset(&msg_serv,0,sizeof(msg_serv));
    ret = recv(socket_client,&msg_serv,sizeof(msg_serv),0);
    if(ret <0){
        perror("recv err:");
        return -17;
    }else if(ret == 0){
        printf("peer close it\n");
        close (socket_client);
        return 0;
    }
    printf("serv get data:temp%d hud%d cnt%d des:%s\n",ntohl(msg_serv.temp),ntohl(msg_serv.humidty)，ntohs(msg_serv.cnt),msg_serv.des);
    msg_serv.cnt = ntohs(msg_serv.cnt);
    msg_serv.cnt++;
    msg_serv.cnt = htons(msg_serv.cnt);
    strcpy(msg_serv.des,"your msg is done");
    ret = send(socket_client,&msg_serv,sizeof(msg_serv),0);
    if(ret <0){
        perror("send err:");
        return -18;
    }
    return 0;
}
int main(void )
{
    int ret;
    int i;
    int socket_serv;
    int socket_client;
    struct sockaddr_in  serv_addr;
    struct sockaddr_in  client_addr;
    socklen_t  addrlen;
    struct msg_struct msg_serv;
    socket_serv = socket(AF_INET, SOCK_STREAM, 0);
    if(socket_serv < 0){
        perror("serv socket err");
        return -12;
    }
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);  
    serv_addr.sin_addr.s_addr =  INADDR_ANY;  //代码自动获取本机ip地址
    ret = bind(socket_serv,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
    if(ret <0){
        perror("bind err");
        return -13;
    }
    ret = listen(socket_serv,5);
    if(ret <0){
        perror("listen err");
        return -14;
    }
    /*将 socket_serv加入 readfdset*/
    FD_SET(socket_serv,&readfdset);
    max = socket_serv;
loop:
    readfdset_backup = readfdset;
    ret = select(max+1,&readfdset_backup,NULL,NULL,NULL);
    if(ret <0){
        perror("select err");
        return -15;
    }
    else if(ret == 0){
        printf("select timeout \n");
        int do_something_others(void);
        goto loop;
    /*代码执行到这里，证明有fd发生事件了*/
    FD_ISSET(socket_serv,&readfdset_backup)){
        addrlen = sizeof(client_addr);
        socket_client = accept(socket_serv,(struct sockaddr *)&client_addr,&addrlen);
        if(socket_client <0){
            perror("accept err:");
            return -16;
            }
        //保存新的套接字通信
        cket_fds[socket_top] = socket_client;
        socket_top++;
        FD_SET(socket_client,&readfdset);   //将新的加入到集合中
        max = max > socket_client ? max :socket_client;
        printf("serv detect connect peer ip:%s port:%d\n",inet_ntoa(client_addr.sin_addr),ntohs( client_addr.sin_port));
        goto loop;
    }
    for(i=0;i<socket_top;i++){
        if(FD_ISSET(socket_fds[i],&readfdset_backup)){
            //deal socket
            serv_do_client_something(socket_fds[i]);
        }
    }
    goto loop;
    /*
        注意, 客户端 在socket和connect之间 有一个操作bind
            客户端可以指定自己的端口号, 但是如果省去
            connect的时候,发现没有端口号,系统自动分配一个.
    */
    while(1){
        /*使用新的 socket发送和接受
            recv
        ssize_t recv(int sockfd, void *buf, size_t len, int flags);
            buf:接收数据存放的位置
            len: buf的大小
            flags: 0
            返回值
                >0 实际接收到的数据
                -1 errno 
                ==0  对方主动或者意外挂掉
        */
        memset(&msg_serv,0,sizeof(msg_serv));
        ret = recv(socket_client,&msg_serv,sizeof(msg_serv),0);
        if(ret <0){
            perror("recv err:");
            return -17;
        }else if(ret == 0){
            printf("peer close it\n");
            close (socket_client);
            return 0;
        }
        printf("serv get data:temp%d hud%d cnt%d des:%s\n",ntohl(msg_serv.temp),ntohl(msg_serv.humidty),ntohs(msg_serv.cnt),msg_serv.des);
        msg_serv.cnt = ntohs(msg_serv.cnt);
        msg_serv.cnt++;
        msg_serv.cnt = htons(msg_serv.cnt);
        strcpy(msg_serv.des,"your msg is done");
        /*
            send    
            ssize_t send(int sockfd, const void *buf, size_t len, int flags);
            len: 是你要发送的数据长度
            返回值 
                >=0 实际发送
                -1   errno
        */
        ret = send(socket_client,&msg_serv,sizeof(msg_serv),0);
        if(ret <0){
        perror("send err:");
            return -18;
        }
    }
    close(socket_client);
}

客户端程序client.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include "comm.h"
int main(void )
{
    int ret;
    int socket_serv;
    struct sockaddr_in  serv_addr;
    struct msg_struct msg_cli;
    socket_serv = socket(AF_INET, SOCK_STREAM, 0);
    if(socket_serv < 0){
        perror("client socket err");
        return -12;
    }
    /*
        注意, 客户端 在socket和connect之间 有一个操作bind
            客户端可以指定自己的端口号, 但是如果省去
            connect的时候,发现没有端口号,系统自动分配一个，一般都不写。
    */
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    serv_addr.sin_addr.s_addr =  inet_addr( "149.28.27.109");
    ret = connect(socket_serv,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
    if(ret <0){
        perror("connect err");
        return -12;
    }
    memset(&msg_cli,0,sizeof(msg_cli));
    msg_cli.temp = htonl(28);
    msg_cli.humidty = htonl(80);
    msg_cli.cnt = htons(0);
    msg_cli.msgtype = 12;
    strcpy(msg_cli.des,"hello msg come from client");
    while(1){
        strcpy(msg_cli.des,"hello msg come from client");
        ret = send(socket_serv,&msg_cli,sizeof(msg_cli),0);
        if(ret <0){
            perror("client send err:");
            return -18;
        }
        memset(&msg_cli,0,sizeof(msg_cli));
        ret = recv(socket_serv,&msg_cli,sizeof(msg_cli),0);
        if(ret <0){
            perror("client recv err:");
            return -17;
        }else if(ret == 0){
            printf("peer close it\n");
            close (socket_serv);
            return 0;
        }
        printf("client get data:temp%d humm%d cnt%d des:%s\n",ntohl(msg_cli.temp),ntohl(msg_cli.humidty),ntohs(msg_cli.cnt),msg_cli.des);
        sleep(1);
    }
    close(socket_serv);
    return 0;
}

多进程并发

多进程并发在嵌入式开发中是最常用的一种服务器并发方式，程序如下：
头文件com.h 

#ifndef TCP_STRUCT_TEST_H
#define TCP_STRUCT_TEST_H

#define PORT 7200

struct data_package
{
    int temp;
    int hum;
    short cnt;
    char info[64];
}__attribute__((packed));

#endif

服务器程序server.c

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

#include "com.h"

struct pthread_s
{
    int server;
    pthread_t pid;
};

void *pthread_client(void *pth)
{
    struct pthread_s *p = pth;
    int resize;
    struct data_package data;
    int res;
    while(1)
    {
        resize = recv(p->server,&data,sizeof(data),0);
        if(resize < 0)
        {
            perror("recv()");
            close(p->server);
            return NULL;
        }
        else if(resize == 0)
        {
            printf("peer close!\n");
            close(p->server);
            return NULL;
        }

        data.temp = ntohl(data.temp);
        data.hum = ntohl(data.hum);
        data.cnt = ntohs(data.cnt);

        printf("[%d] temperture:%d,humidty:%d,%s\n",data.cnt,data.temp,\
                data.hum,data.info);

        strcpy(data.info,"get your message!");

        //data.cnt = ntohs(data.cnt);
        data.cnt++;
        data.cnt = htons(data.cnt);

        data.temp = htonl(data.temp);
        data.hum = htonl(data.hum);

        res = send(p->server,&data,sizeof(data),0);
        if(res < 0)
        {
            perror("send()");
            close(p->server);
            return NULL;
        }
    }

    close(p->server);
    return NULL;

}

int main(void)
{
    int socket_serv;
    int res;
    int client;
    struct sockaddr_in sockaddr;
    struct sockaddr_in client_addr;

    socklen_t client_len;

    pthread_t pid;
    struct pthread_s *p;

    socket_serv = socket(AF_INET,SOCK_STREAM,0);
    if(socket_serv < 0)
    {
        perror("socket()");
        exit(-1);
    }

    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = PORT;
    //sockaddr.sin_addr.s_addr = inet_addr("192.168.3.188");
    sockaddr.sin_addr.s_addr = INADDR_ANY;

    res = bind(socket_serv,(struct sockaddr *)&sockaddr,sizeof(sockaddr));
    if(res < 0)
    {
        perror("bind()");
        exit(-2);
    }

    res = listen(socket_serv,5);
    if(res < 0)
    {
        perror("listen()");
        exit(-3);
    }
    while(1)
    {
        client_len=sizeof(client_addr);
        client = accept(socket_serv,(struct sockaddr *)&client_addr,\
                &client_len);
        if(client < 0)
        {
            perror("accept()");
            exit(-4);
        }
        printf("connect port:%d,address:%s\n",ntohs(client_addr.sin_port),\
                inet_ntoa(client_addr.sin_addr));

        p=malloc(sizeof(*p));
        p->server = client;
        pthread_create(&pid,NULL,pthread_client,p);
        p->pid = pid;
    }

    exit(0);
}

客户端程序client.c

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

#include "com.h"
#define BUFSIZE 128
int main(void)
{
    int socket_client;
    int res;
    struct sockaddr_in sockaddr;
    int resize;
    socklen_t client_len;
    struct data_package data_c;

    socket_client = socket(AF_INET,SOCK_STREAM,0);
    if(socket_client < 0)
    {
        perror("socket()");
        exit(-1);
    }

    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = PORT;
    sockaddr.sin_addr.s_addr = inet_addr("192.168.3.188");

    res = connect(socket_client,(struct sockaddr *)&sockaddr,\
            sizeof(sockaddr));
    if(res < 0)
    {
        perror("bind()");
        exit(-2);
    }
    data_c.temp = 28;
    data_c.hum = 59;
    data_c.cnt = 0;

    while(1)
    {
        strcpy(data_c.info,"message have sended!");
        data_c.temp = htonl(data_c.temp);
        data_c.hum = htonl(data_c.hum);
        data_c.cnt = htons(data_c.cnt);
        res = send(socket_client,&data_c,sizeof(data_c),0);
        if(res < 0)
        {
            perror("send()");
            exit(-6);
        }

        memset(&data_c,0,sizeof(data_c));
        resize = recv(socket_client,&data_c,sizeof(data_c),0);
        if(resize < 0)
        {
            perror("recv()");
            exit(-5);
        }

        data_c.temp = ntohl(data_c.temp);
        data_c.hum = ntohl(data_c.hum);
        data_c.cnt = ntohs(data_c.cnt);

        printf("[%d] temperture:%d,humidty:%d,%s\n",data_c.cnt,data_c.temp,\
                data_c.hum,data_c.info);
        sleep(1);

    }
    close(socket_client);

    exit(0);
}
风翼随心
关注
专栏目录
【C语言】Linux实现高并发处理的过程
数字人生
01-06 1709
一、实现高并发的几种策略 C语言本身并没有内建的多线程支持（新版C语言支持，但用得不多），但是在多数操作系统中，可以使用库来实现多线程编程。例如，在POSIX兼容系统上，可以使用 pthreads 库来创建和管理线程。然而，传统的多线程存在着资源限制，比如每个线程都需要独立的堆栈空间，上下文切换开销大，线程数量多时还会导致竞争情况加剧。 为了兼顾高并发和高性能，可以采取以下几种策略： 1. 线程池(Thread Pools)：创建一个线程池来管理一定数量的线程，避免了频繁创建和销毁线程的开销，可以复用线程
Linux高性能服务器编程电子版
03-22
书中的内容涵盖了广泛的Linux系统编程和服务器优化技术，旨在帮助读者提升系统的性能和可扩展性。 在Linux操作系统中，高性能服务器编程涉及到多个关键领域，包括但不限于： 1. **多线程与并发处理**：Linux提供了...
Linux 编程学习书籍
云满笔记
12-02 1919
Linux 入门书籍。Linux 进阶书籍。
linux下的并发编程详解
Leon的博客
04-06 1451
使用应用级并发的应用程序称为并发程序（concurrent program）。现代操作系统提供3种基本的构造并发程序的方法：进程、I/O多路复用和线程。下面将分别予以讨论。 1. 基于进程的并发编程 我们可以利用熟悉的fork、execve及waitpid函数来开发基于进程的并发编程。下面以构造并发服务器为例，在服务器程序中，父进程接受客户端的连接请求，然后创建一个新的子进程为每一...
Linux高并发服务器开发 ：linux系统编程 1-2linux环境下编写c程序
qq_42865685的博客
09-17 766
gedit是一个GNOME桌面环境下兼容UTF-8的文本编辑器。它使用GTK+编写而成，因此它十分的简单易用，有良好的语法高亮，对中文支持很好，支持包括gb2312、gbk在内的多种字符编码。gedit是一个自由软件。这是 Linux 下的一个纯文本编辑器,但你也可以把它用来当成是一个集成开发环境 (IDE), 它会根据不同的语言高亮显现关键字和标识符。gedit是一个Linux环境下的文本编辑器，类似windows下的写字板程序，在不需要特别复杂的编程环境下，作为基本的文本编辑器比较合适。
Linux高并发服务器开发-4网络编程
xiangchaoyuchang的博客
06-09 673
所谓 socket（套接字），就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口， 是应用程序与网络协议根进行交互的接口。socket 是由 IP 地址和端口结合的，提供向应用层进程传送数据包的机制。socket 本身有“插座”的意思，在 Linux 环境下，用于表示进程间网络通信的特殊文件类型。
Linux高性能服务器编程,linux高性能服务器编程 pdf,C,C++
09-10
2. **多线程与并发处理**：在Linux环境中，如何通过多线程技术来提高服务器并发性能，包括线程创建、同步和通信机制，如互斥锁、条件变量、信号量等。 3. **异步I/O模型**：深入理解各种I/O模型，如阻塞I/O、非阻塞...
linux高性能服务器编程
06-16
总的来说，《Linux高性能服务器编程》涵盖了从基础的系统接口到高级的性能优化策略，为C++开发者提供了全面的Linux服务器开发知识。无论是初学者还是经验丰富的开发者，都能从中受益，提升自己的技能水平，更好地...
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
深入理解并发编程
10-24
linux大神paul作品，详细介绍了并发编程的各种概念。内存屏障，mutex等。值得一读。
黑马_Linux网络编程-网络基础-socket编程-高并发服务器
02-16
黑马程序员linux服务器开发网络编程配套文档，很好的参考资料
JavaNIOpdf书籍
08-21
JavaNIO书籍，很全面，可供IT技术人员以及正在学习的同学提供学习资料，好好珍惜。
Linux高并发服务器开发（一）Linux系统编程入门
qq_44566415的博客
08-04 199
库文件是计算机上的一类文件，可以简单的把库文件看成一种代码仓库，提供给使用者一些可以直接拿来用的变量、函数或类库是一种特殊的程序，编写库的程序和编写一般的程序区别不大，只是库不能单独运行库文件有两种：静态库和动态库（共享库）。静态库在程序的链接阶段被复制到了程序中；动态库在链接阶段没有被复制到程序中，而是程序在运行时由系统动态加载到内存中供程序调用库的好处是：1、代码保密；2、方便部署和分发。
Linux C/C++并发编程实战（1）谈谈并发编程
二进制君
03-22 289
使用并发编程可以将计算密集型的任务分解成多个子任务，并将这些子任务分配到不同的核心或处理器上并行执行，以提高程序的速度和吞吐量。为了避免这些问题，需要使用适当的同步机制，如锁、信号量、原子操作等，来协调不同线程之间的操作次序，保证共享资源的正确性和稳定性。在多线程编程中，如果某个操作涉及到共享数据，那么就需要保证这个操作的原子性，以避免多个线程同时修改同一个数据导致数据错误的问题。在并发编程中，程序由多个独立运行的线程或进程组成，这些线程或进程可以并行执行，从而实现任务的同时执行。
【并发程序设计】总篇集 Linux下 C语言 实现并发程序设计
最新发布
2201_75563094的博客
06-03 1640
在Linux中，进程是操作系统分配资源和调度运行的基本单位。Linux中的进程有以下用处：进程在Linux系统中扮演着至关重要的角色，它们不仅提高了系统的资源利用率，还实现了多任务的并行处理，使得用户可以更加高效地进行工作。以下是一些关于Linux进程的重要概念：进程的内容通常包括以下几个主要部分：在Linux中，子进程是由父进程创建的进程。当一个进程被创建时，它会自动成为一个新进程的父进程，而新进程则成为子进程。子进程可以通过系统调用来创建。回收子进程的必要性：回收子进程不仅是为了维护操作系统资源的有效性
Linux网络编程(高并发服务器)
m0_49476241的博客
08-17 1178
本篇文章带大家学习Linux网络编程中的高并发服务器。首先我们需要了解什么是高并发服务器，然后是学习如何来编写高并发服务器。高并发服务器是指能够同时处理大量并发请求的服务器系统。在网络应用中，当多个用户或客户端同时请求服务器时，服务器需要能够高效地处理这些请求，并且保持良好的性能和稳定性。1.多线程或多进程处理：采用多线程或多进程的方式可以使服务器能够同时处理多个请求。每个线程或进程负责处理一个请求，从而提高服务器的并发处理能力。
Linux下使用C语言实现高并发服务器
qq_61585528的博客
04-11 1365
Linux下使用C语言实现高并发服务器
Linux高并发服务器开发——Linux多进程开发
Atticus的博客
04-28 925
进程可以使用的资源上限（Resource Limit）（指令：ulimit -a） 第一个会话终端 第二个会话终端 第三个会话终端 按u输入指定用户，比方这里我输入ubuntu在第一个会话终端可以看到第二个会话终端的进程信息 kill进程，发现第二个会话终端断联了把当前进程强制杀死 或者 kill命令默认的信号是15，即kill -15，此时系统发送一个SIGTERM的信号给对应程序，当程序接收到该信号后，具体如何处理是自己可以决定的（可结束，可忽略），结束前一般会进行一些"准备工作"。由于S
Linux系统编程：多进程并发服务器实现与性能考虑
"Linux系统编程-网络并发服务器与Socket编程" 在设计和实现一个多进程并发服务器时，特别是针对高频金融交易数据接收这样的高负载场景，有以下几个关键知识点需要考虑： 1. **多进程并发模型**：多进程并发是提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值