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

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。

相关文章

C#如何优雅地取消进程的执行之Cancellation详解

C#如何优雅地取消进程的执行之Cancellation详解

《C#如何优雅地取消进程的执行之Cancellation详解》本文介绍了.NET框架中的取消协作模型,包括CancellationToken的使用、取消请求的发送和接收、以及如何处理取消事件... 目录概述与取消线程相关的类型代码举例操作取消vs对象取消监听并响应取消请求轮询监听通过回调注册进行监听使用Wa
阅读更多...
系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

本章知识考点：         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识
阅读更多...
高并发环境中保持幂等性

高并发环境中保持幂等性

在高并发环境中保持幂等性是一项重要的挑战。幂等性指的是无论操作执行多少次，其效果都是相同的。确保操作的幂等性可以避免重复执行带来的副作用。以下是一些保持幂等性的常用方法： 唯一标识符： 请求唯一标识：在每次请求中引入唯一标识符（如 UUID 或者生成的唯一 ID），在处理请求时，系统可以检查这个标识符是否已经处理过，如果是，则忽略重复请求。幂等键（Idempotency Key）：客户端在每次
阅读更多...
[Linux]：进程(下)

[Linux]：进程(下)

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：Linux学习 贝蒂的主页：Betty’s blog 1. 进程终止 1.1 进程退出的场景 进程退出只有以下三种情况： 代码运行完毕，结果正确。代码运行完毕，结果不正确。代码异常终止（进程崩溃）。 1.2 进程退出码 在编程中，我们通常认为main函数是代码的入口，但实际上它只是用户级
阅读更多...
【STM32】SPI通信-软件与硬件读写SPI

【STM32】SPI通信-软件与硬件读写SPI

SPI通信-软件与硬件读写SPI 软件SPI一、SPI通信协议1、SPI通信2、硬件电路3、移位示意图4、SPI时序基本单元(1)开始通信和结束通信(2)模式0---用的最多(3)模式1(4)模式2(5)模式3 5、SPI时序(1)写使能(2)指定地址写(3)指定地址读 二、W25Q64模块介绍１、W25Q64简介２、硬件电路３、W25Q64框图４、Flash操作注意事项软件SPI读写W2
阅读更多...
多线程解析报表

多线程解析报表

假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要提示解析完成。 Way1 join import java.time.LocalTime;public class Main {public static void main(String[] args) thro
阅读更多...
vue2 组件通信

vue2 组件通信

props + emits props:用于接收父组件传递给子组件的数据。可以定义期望从父组件接收的数据结构和类型。‘子组件不可更改该数据’emits:用于定义组件可以向父组件发出的事件。这允许父组件监听子组件的事件并作出响应。(比如数据更新) props检查属性 属性名类型描述默认值typeFunction指定 prop 应该是什么类型，如 String, Number, Boolean,
阅读更多...
Java并发编程之——BlockingQueue（队列）

Java并发编程之——BlockingQueue（队列）

一、什么是BlockingQueue BlockingQueue即阻塞队列，从阻塞这个词可以看出，在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种： 1. 当队列满了的时候进行入队列操作2. 当队列空了的时候进行出队列操作123 因此，当一个线程试图对一个已经满了的队列进行入队列操作时，它将会被阻塞，除非有另一个线程做了出队列操作；同样，当一个线程试图对一个空
阅读更多...
Java 多线程概述

Java 多线程概述

多线程技术概述   1.线程与进程 进程：内存中运行的应用程序，每个进程都拥有一个独立的内存空间。线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换、并发执行，一个进程最少有一个线程，线程实际数是在进程基础之上的进一步划分，一个进程启动之后，进程之中的若干执行路径又可以划分成若干个线程 2.线程的调度 分时调度：所有线程轮流使用CPU的使用权，平均分配时间抢占式调度
阅读更多...
Java 多线程的基本方式

Java 多线程的基本方式

Java 多线程的基本方式 基础实现两种方式： 通过实现Callable 接口方式（可得到返回值)：
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2