广播，组播，多进程并发通信，多线程并发通信

2024-04-25 07:20
文章标签 广播 并发 多线程 进程 通信 组播

本文主要是介绍广播，组播，多进程并发通信，多线程并发通信，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

广播服务器搭建：

#include <myhead.h>

#define PORT 8888
#define IP "192.168.124.255"

int main(int argc, const char *argv[])
{
    //创建流套接字
    int sfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sfd < 0){
        fprintf(stderr,"line:%d ",__LINE__);
        perror("socket");
        return -1;
    }
    printf("创建流套接字成功 sfd=%d __%d__\n",sfd,__LINE__);
    //允许端口号被复用
    int reuse = 1;
    if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("setsockopt");
        return -1;    
    }

    //填充接收方地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family         = AF_INET;
    sin.sin_port         = htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);
    //绑定服务器自身的地址信息
    if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin)) < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("bind");
        return -1;    
    }
    printf("bind success __%d__\n",__LINE__);


    //存储数据包发送的地址信息
    char buf[128] = "";
    struct sockaddr_in cin;
    socklen_t addrlen = sizeof(cin);
    while(1){
        bzero(buf,sizeof(buf));
        //接收
        if(recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&cin,&addrlen) < 0){
            fprintf(stderr,"line=%d",__LINE__);
            perror("recvfrom");
            return -1;    
        }
        printf("[%s:%d]:%s __%d__\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),buf,__LINE__);

    }
    close(sfd);
    return 0;
}

客户端搭建：

#include <myhead.h>

#define PORT 8888
#define IP "192.168.124.255"

int main(int argc, const char *argv[])
{
    //创建流套接字
    int cfd = socket(AF_INET,SOCK_DGRAM,0);
    if(cfd < 0){
        fprintf(stderr,"line:%d ",__LINE__);
        perror("socket");
        return -1;
    }
    printf("creat ok cfd=%d __%d__",cfd,__LINE__);

    //设置允许广播
    int broad = 1;
    if(setsockopt(cfd,SOL_SOCKET,SO_BROADCAST,&broad,sizeof(broad)) < 0){
        fprintf(stderr,"line:%d ",__LINE__);
        perror("socket");
        return -1;
    }
    printf("允许广播成功\n");


    //填充接收方地址信息
    struct sockaddr_in cin;
    cin.sin_family      = AF_INET;
    cin.sin_port        = htons(PORT);
    cin.sin_addr.s_addr = inet_addr(IP);
    //发送
    char buf[128];
    struct sockaddr_in rcvaddr;
    socklen_t addrlen = sizeof(cin);
    while(1){
        bzero(buf,sizeof(buf));
        printf("请输入：");
        fgets(buf,sizeof(buf),stdin);
        buf[strlen(buf)-1] = 0;
        if(sendto(cfd,buf,sizeof(buf),0,(struct sockaddr*)&cin,sizeof(cin)) < 0){
            fprintf(stderr,"line=%d",__LINE__);
            perror("sendto");
            return -1;    
        }
        printf("发送成功\n");
    }
    close(cfd);
    return 0;
}

组播服务器搭建：

#include <myhead.h>

#define PORT 8888
#define IP "192.168.124.73"
#define GRP_IP "224.1.2.3"
int main(int argc, const char *argv[])
{
    //创建流套接字
    int sfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sfd < 0){
        fprintf(stderr,"line:%d ",__LINE__);
        perror("socket");
        return -1;
    }
    printf("创建流套接字成功 sfd=%d __%d__\n",sfd,__LINE__);
    //允许端口号被复用
    int reuse = 1;
    if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("setsockopt");
        return -1;    
    }
    //加入多播组
    struct ip_mreqn mq;
    mq.imr_multiaddr.s_addr   = inet_addr(GRP_IP); //加入组播IP
    mq.imr_address.s_addr     = inet_addr(IP);
    mq.imr_ifindex             = 0;    //网络设备索引号

    if(setsockopt(sfd,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mq,sizeof(mq)) < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("setsockopt");
        return -1;    
    }
    printf("加入小组成功[%s]\n",GRP_IP);
    //填充服务器地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family         = AF_INET;
    sin.sin_port         = htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);
    //绑定服务器自身的地址信息
    if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin)) < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("bind");
        return -1;    
    }
    printf("bind success __%d__\n",__LINE__);

    //存储数据包发送的地址信息
    char buf[128] = "";
    struct sockaddr_in cin;
    socklen_t addrlen = sizeof(cin);
    while(1){
        bzero(buf,sizeof(buf));
        //接收
        if(recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&cin,&addrlen) < 0){
            fprintf(stderr,"line=%d",__LINE__);
            perror("recvfrom");
            return -1;    
        }
        printf("[%s:%d]:%s __%d__\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),buf,__LINE__);
    }
    close(sfd);
    return 0;
}

组播客户端搭建：

#include <myhead.h>

#define PORT 8888
#define IP "224.1.2.3"

int main(int argc, const char *argv[])
{
    //创建流套接字    int cfd = socket(AF_INET,SOCK_DGRAM,0);
    int cfd = socket(AF_INET,SOCK_DGRAM,0);
    if(cfd < 0){
        fprintf(stderr,"line:%d ",__LINE__);
        perror("socket");
        return -1;
    }
    printf("creat ok cfd=%d __%d__",cfd,__LINE__);
    //允许端口被复用
    int reuse = 1;
    if(setsockopt(cfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("setsockopt");
        return -1;    
    }

    struct sockaddr_in sin;
    sin.sin_family      = AF_INET;
    sin.sin_port        = htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);
    //发送
    char buf[128];
    struct sockaddr_in rcvaddr;
    socklen_t addrlen = sizeof(sin);
    while(1){
        bzero(buf,sizeof(buf));
        printf("请输入：");
        fgets(buf,sizeof(buf),stdin);
        buf[strlen(buf)-1] = 0;
        if(sendto(cfd,buf,sizeof(buf),0,(struct sockaddr*)&sin,sizeof(sin)) < 0){
            fprintf(stderr,"line=%d",__LINE__);
            perror("sendto");
            return -1;    
        }
        printf("发送成功\n");
    }
    close(cfd);
    return 0;
}

多进程通信（TCP）：

#include <myhead.h>

#define IP "192.168.124.73"
#define PORT 8888

void recycle_zombie()
{
    while(waitpid(-1,NULL,WNOHANG)<0);
}

int do_cli_msg(int newfd,struct sockaddr_in cin);
int main(int argc, const char *argv[])
{
    //捕获17号信号
    if(signal(17,recycle_zombie) == SIG_ERR){
        fprintf(stderr,"line=%d",__LINE__);
        perror("signal");
        return -1;
    }
    //创建流式套接字
    int sfd = socket(AF_INET,SOCK_STREAM,0);
    if(sfd < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("socket");
        return -1;
    }
    printf("创建流式套接字成功 sfd=%d __%d__\n",sfd,__LINE__);
    //允许端口号被重复使用
    int reuse = 1;
    if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("setsockopt");
        return -1;    
    }
    
    //填充服务器的地址信息结构体，真实的地址信息结构体根据地址族制定
    //AF_INET -->man 7 ip
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port   = htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);
    //绑定服务器自身的地址信息
    if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin)) < 0){
        fprintf(stderr,"line:%d",__LINE__);
        perror("bind");
        return -1;
    }
    printf("bind success __%d__\n",__LINE__);
    //套接字设置为被动监听
    if(listen(sfd,128) < 0 ){
        fprintf(stderr,"line:%d",__LINE__);
        perror("listen");
        return -1;    
    }
    printf("listen success __%d__\n",__LINE__);
    //获取链接成功的套接字
    struct sockaddr_in cin;  //存储客户端信息
    socklen_t addrlen = sizeof(cin);
    //会从已经完成链接队列的对头获取一个客户端的信息，生成一个新的文件描述符
    //accept(sfd,NULL,NULL)
    int newfd;    //接收
    pid_t pid = 0;
    while(1){
        newfd = accept(sfd,(struct sockaddr*)&cin,&addrlen);
        if(newfd < 0){
            fprintf(stderr,"line:%d",__LINE__);
            perror("accept");
            return -1;
        }
        printf("[%s:%d] 客户端链接成功 newfd=%d __%d__\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,__LINE__);

        pid = fork();
        if(pid == 0){
            close(sfd);
            do_cli_msg(newfd,cin);
            close(newfd);
            exit(0);
        }
        else if(pid > 0){
            close(newfd);
        }
        else{
            fprintf(stderr,"line:%d",__LINE__);
            perror("fork");
            return -1;
        }

    }
    
    
    //关闭文件描述符

    close(sfd);
    return 0;
}

int do_cli_msg(int newfd,struct sockaddr_in cin)
{
    char buf[128];
    ssize_t res;
    while(1){
        bzero(buf,sizeof(buf));
        //接收
        res = recv(newfd,buf,sizeof(buf),0);
        if(res < 0){    
            fprintf(stderr,"line:%d",__LINE__);
            perror("recv");
            return -1;
        }
        else if(res == 0){
            printf("[%s:%d] 客户端断开 newfd=%d :%s __%d__\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf,__LINE__);
            break;
        }
        printf("[%s:%d]newfd=%d :%s __%d__\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf,__LINE__);

        //发送
        strcat(buf," I GET IT!");
        if(send(newfd,buf,sizeof(buf),0) < 0){
            fprintf(stderr,"line:%d",__LINE__);
            perror("send");
            return -1;
        }
        printf("send success __%d__\n",__LINE__);
    }
    return 0;

}

多线程通信：

#include <myhead.h>

#define IP "192.168.124.73"
#define PORT 8888

struct CliInfo{
    int newfd;
    struct sockaddr_in cin;
};

void* do_cli_msg(void* arg);
int main(int argc, const char *argv[])
{
    //创建流式套接字
    int sfd = socket(AF_INET,SOCK_STREAM,0);
    if(sfd < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("socket");
        return -1;
    }
    printf("创建流式套接字成功 sfd=%d __%d__\n",sfd,__LINE__);
    //允许端口号被重复使用
    int reuse = 1;
    if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0){
        fprintf(stderr,"line=%d",__LINE__);
        perror("setsockopt");
        return -1;    
    }
    
    //填充服务器的地址信息结构体，真实的地址信息结构体根据地址族制定
    //AF_INET -->man 7 ip
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port   = htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);
    //绑定服务器自身的地址信息
    if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin)) < 0){
        fprintf(stderr,"line:%d\n",__LINE__);
        perror("bind");
        return -1;
    }
    printf("bind success __%d__\n",__LINE__);
    //套接字设置为被动监听
    if(listen(sfd,128) < 0 ){
        fprintf(stderr,"line:%d",__LINE__);
        perror("listen");
        return -1;    
    }
    printf("listen success __%d__\n",__LINE__);
    //获取链接成功的套接字
    struct sockaddr_in cin;  //存储客户端信息
    socklen_t addrlen = sizeof(cin);
    //会从已经完成链接队列的对头获取一个客户端的信息，生成一个新的文件描述符
    //accept(sfd,NULL,NULL)
    int newfd;    //接收
    pthread_t tid;
    struct CliInfo dcli;
    while(1){
        newfd = accept(sfd,(struct sockaddr*)&cin,&addrlen);
        if(newfd < 0){
            fprintf(stderr,"line:%d",__LINE__);
            perror("accept");
            return -1;
        }
        printf("[%s:%d] 客户端链接成功 newfd=%d __%d__\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,__LINE__);
        //运行到此时则代表客户端链接成功，需要创建一个分支线程负责交互
        //分之线程负责交互
        dcli.newfd = newfd;
        dcli.cin = cin;

        if(pthread_create(&tid,NULL,do_cli_msg,(void*)&dcli) != 0){
            fprintf(stderr,"line:%d pthread_create failed\n",__LINE__);
            return -1;
        }
        pthread_detach(tid);
        
    }
    
    
    //关闭文件描述符

    close(sfd);
    return 0;
}

void* do_cli_msg(void* arg)
{
    int newfd = ((struct CliInfo*)arg)->newfd;
    struct sockaddr_in cin = ((struct CliInfo*)arg)->cin;
    char buf[128];
    ssize_t res;
    while(1){
        bzero(buf,sizeof(buf));
        //接收
        res = recv(newfd,buf,sizeof(buf),0);
        if(res < 0){    
            fprintf(stderr,"line:%d",__LINE__);
            perror("recv");
            break;;
        }
        else if(res == 0){
            printf("[%s:%d] 客户端断开 newfd=%d :%s __%d__\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf,__LINE__);
            break;
        }
        printf("[%s:%d]newfd=%d :%s __%d__\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf,__LINE__);

        //发送
        strcat(buf," I GET IT!");
        if(send(newfd,buf,sizeof(buf),0) < 0){
            fprintf(stderr,"line:%d",__LINE__);
            perror("send");
            break;
        }
        printf("send success __%d__\n",__LINE__);
    }
    close(newfd);
    pthread_exit(NULL);
}

这篇关于广播，组播，多进程并发通信，多线程并发通信的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/934037。

相关文章

Linux进程CPU绑定优化与实践过程

Linux进程CPU绑定优化与实践过程

《Linux进程CPU绑定优化与实践过程》Linux支持进程绑定至特定CPU核心,通过sched_setaffinity系统调用和taskset工具实现,优化缓存效率与上下文切换,提升多核计算性能,适... 目录1. 多核处理器及并行计算概念1.1 多核处理器架构概述1.2 并行计算的含义及重要性1.3 并
阅读更多...
Linux下进程的CPU配置与线程绑定过程

Linux下进程的CPU配置与线程绑定过程

《Linux下进程的CPU配置与线程绑定过程》本文介绍Linux系统中基于进程和线程的CPU配置方法,通过taskset命令和pthread库调整亲和力,将进程/线程绑定到特定CPU核心以优化资源分配... 目录1 基于进程的CPU配置1.1 对CPU亲和力的配置1.2 绑定进程到指定CPU核上运行2 基于
阅读更多...
Javaee多线程之进程和线程之间的区别和联系(最新整理)

Javaee多线程之进程和线程之间的区别和联系(最新整理)

《Javaee多线程之进程和线程之间的区别和联系(最新整理)》进程是资源分配单位,线程是调度执行单位,共享资源更高效,创建线程五种方式:继承Thread、Runnable接口、匿名类、lambda,r... 目录进程和线程进程线程进程和线程的区别创建线程的五种写法继承Thread,重写run实现Runnab
阅读更多...
怎样通过分析GC日志来定位Java进程的内存问题

怎样通过分析GC日志来定位Java进程的内存问题

《怎样通过分析GC日志来定位Java进程的内存问题》：本文主要介绍怎样通过分析GC日志来定位Java进程的内存问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、GC 日志基础配置1. 启用详细 GC 日志2. 不同收集器的日志格式二、关键指标与分析维度1.
阅读更多...
Java进程异常故障定位及排查过程

Java进程异常故障定位及排查过程

《Java进程异常故障定位及排查过程》：本文主要介绍Java进程异常故障定位及排查过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、故障发现与初步判断1. 监控系统告警2. 日志初步分析二、核心排查工具与步骤1. 进程状态检查2. CPU 飙升问题3. 内存
阅读更多...
使用Python实现可恢复式多线程下载器

使用Python实现可恢复式多线程下载器

《使用Python实现可恢复式多线程下载器》在数字时代,大文件下载已成为日常操作,本文将手把手教你用Python打造专业级下载器,实现断点续传,多线程加速,速度限制等功能,感兴趣的小伙伴可以了解下... 目录一、智能续传：从崩溃边缘抢救进度二、多线程加速：榨干网络带宽三、速度控制：做网络的好邻居四、终端交互
阅读更多...
Windows的CMD窗口如何查看并杀死nginx进程

Windows的CMD窗口如何查看并杀死nginx进程

《Windows的CMD窗口如何查看并杀死nginx进程》：本文主要介绍Windows的CMD窗口如何查看并杀死nginx进程问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地... 目录Windows的CMD窗口查看并杀死nginx进程开启nginx查看nginx进程停止nginx服务
阅读更多...
Java进程CPU使用率过高排查步骤详细讲解

Java进程CPU使用率过高排查步骤详细讲解

《Java进程CPU使用率过高排查步骤详细讲解》：本文主要介绍Java进程CPU使用率过高排查的相关资料,针对Java进程CPU使用率高的问题,我们可以遵循以下步骤进行排查和优化,文中通过代码介绍... 目录前言一、初步定位问题1.1 确认进程状态1.2 确定Java进程ID1.3 快速生成线程堆栈二、分析
阅读更多...
RabbitMQ工作模式中的RPC通信模式详解

RabbitMQ工作模式中的RPC通信模式详解

《RabbitMQ工作模式中的RPC通信模式详解》在RabbitMQ中,RPC模式通过消息队列实现远程调用功能,这篇文章给大家介绍RabbitMQ工作模式之RPC通信模式,感兴趣的朋友一起看看吧... 目录RPC通信模式概述工作流程代码案例引入依赖常量类编写客户端代码编写服务端代码RPC通信模式概述在R
阅读更多...
在Spring Boot中实现HTTPS加密通信及常见问题排查

在Spring Boot中实现HTTPS加密通信及常见问题排查

《在SpringBoot中实现HTTPS加密通信及常见问题排查》HTTPS是HTTP的安全版本,通过SSL/TLS协议为通讯提供加密、身份验证和数据完整性保护,下面通过本文给大家介绍在SpringB... 目录一、HTTPS核心原理1.加密流程概述2.加密技术组合二、证书体系详解1、证书类型对比2. 证书获
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2