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

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。

相关文章

Java并发编程必备之Synchronized关键字深入解析

Java并发编程必备之Synchronized关键字深入解析

《Java并发编程必备之Synchronized关键字深入解析》本文我们深入探索了Java中的Synchronized关键字,包括其互斥性和可重入性的特性,文章详细介绍了Synchronized的三种... 目录一、前言二、Synchronized关键字2.1 Synchronized的特性1. 互斥2.
阅读更多...
Python异步编程中asyncio.gather的并发控制详解

Python异步编程中asyncio.gather的并发控制详解

《Python异步编程中asyncio.gather的并发控制详解》在Python异步编程生态中,asyncio.gather是并发任务调度的核心工具,本文将通过实际场景和代码示例,展示如何结合信号量... 目录一、asyncio.gather的原始行为解析二、信号量控制法：给并发装上"节流阀"三、进阶控制
阅读更多...
Redis中高并发读写性能的深度解析与优化

Redis中高并发读写性能的深度解析与优化

《Redis中高并发读写性能的深度解析与优化》Redis作为一款高性能的内存数据库,广泛应用于缓存、消息队列、实时统计等场景,本文将深入探讨Redis的读写并发能力,感兴趣的小伙伴可以了解下... 目录引言一、Redis 并发能力概述1.1 Redis 的读写性能1.2 影响 Redis 并发能力的因素二、
阅读更多...
Java使用多线程处理未知任务数的方案介绍

Java使用多线程处理未知任务数的方案介绍

《Java使用多线程处理未知任务数的方案介绍》这篇文章主要为大家详细介绍了Java如何使用多线程实现处理未知任务数,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 知道任务个数，你可以定义好线程数规则，生成线程数去跑代码说明：1.虚拟线程池：使用 Executors.newVir
阅读更多...
Linux中的进程间通信之匿名管道解读

Linux中的进程间通信之匿名管道解读

《Linux中的进程间通信之匿名管道解读》：本文主要介绍Linux中的进程间通信之匿名管道解读,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、基本概念二、管道1、温故知新2、实现方式3、匿名管道（一）管道中的四种情况（二）管道的特性总结一、基本概念我们知道多
阅读更多...
Linux进程终止的N种方式详解

Linux进程终止的N种方式详解

《Linux进程终止的N种方式详解》进程终止是操作系统中,进程的一个重要阶段,他标志着进程生命周期的结束,下面小编为大家整理了一些常见的Linux进程终止方式,大家可以根据需求选择... 目录前言一、进程终止的概念二、进程终止的场景三、进程终止的实现3.1 程序退出码3.2 运行完毕结果正常3.3 运行完毕
阅读更多...
JAVA封装多线程实现的方式及原理

JAVA封装多线程实现的方式及原理

《JAVA封装多线程实现的方式及原理》：本文主要介绍Java中封装多线程的原理和常见方式,通过封装可以简化多线程的使用,提高安全性,并增强代码的可维护性和可扩展性,需要的朋友可以参考下... 目录前言一、封装的目标二、常见的封装方式及原理总结前言在 Java 中，封装多线程的原理主要围绕着将多线程相关的操
阅读更多...
Windows命令之tasklist命令用法详解(Windows查看进程)

Windows命令之tasklist命令用法详解(Windows查看进程)

《Windows命令之tasklist命令用法详解(Windows查看进程)》tasklist命令显示本地计算机或远程计算机上当前正在运行的进程列表,命令结合筛选器一起使用,可以按照我们的需求进行过滤... 目录命令帮助1、基本使用2、执行原理2.1、tasklist命令无法使用3、筛选器3.1、根据PID
阅读更多...
Nginx实现高并发的项目实践

Nginx实现高并发的项目实践

《Nginx实现高并发的项目实践》本文主要介绍了Nginx实现高并发的项目实践,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录使用最新稳定版本的Nginx合理配置工作进程(workers)配置工作进程连接数(worker_co
阅读更多...
linux本机进程间通信之UDS详解

linux本机进程间通信之UDS详解

《linux本机进程间通信之UDS详解》文章介绍了Unix域套接字（UDS）的使用方法,这是一种在同一台主机上不同进程间通信的方式,UDS支持三种套接字类型：SOCK_STREAM、SOCK_DGRA... 目录基础概念本机进程间通信socket实现AF_INET数据收发示意图AF_Unix数据收发流程图A
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2