WebRTC服务器理论铺垫(三):实现高性能网络服务器的四种方式:fork,select,epoll,开源多路IO库

已于 2023-02-14 13:01:05 修改
阅读量444 收藏 1
点赞数
分类专栏： 服务端开发 文章标签： 服务器 网络 webrtc
于 2023-02-07 16:31:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43398345/article/details/128921220
版权
本文介绍了实现高性能网络服务器的四种主要方式，包括通过fork创建子进程、使用select进行多路复用、利用epoll的高效事件通知以及epoll与fork的结合使用。同时提到了异步事件处理的开源库，如libevent和libuv等，强调了在不同场景下选择合适的方法对服务器性能的重要性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

前言

一、实现高性能网络服务器的四种方式

在之前我们实现的tcp server, tcp client, udp server, udp client中，默认只允许一个连接，在代码逻辑中表现为一个while死循环。为了允许更多的连接，我们需要使用一些机制来实现高性能网络服务器，具体的有以下四种方式。

二、通过fork实现高性能网络服务器

  1. 每收到一个连接就创建一个子进程。
  2. 父进程负责接收连接。
  3. 通过fork来创建子进程
#include<iostream>
#include<stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include<string.h>
#include<netinet/in.h>
#include<unistd.h>
#define PORT 8111
#define MESSAGE_LEN 1024
int main(int argc,char* argv[])
{
    int socket_fd = -1,accept_fd = -1;
    int on = 1;
    int curpos = 0;
    int backlog = 1000;
    int flag = 1;
    int ret = -1;
    char in_buffer[MESSAGE_LEN] = {0,};
    struct sockaddr_in localaddr,remoteaddr;
    //create
    socket_fd = socket(AF_INET, SOCK_STREAM,0);
    if(socket_fd == -1)
    {
      std::cout<<"FAILED to CREATE SOCKET!"<<std::endl;
      exit(-1);
    }
    ret = setsockopt(socket_fd,
                  SOL_SOCKET,
                  SO_REUSEADDR,
                  &flag,
                  (socklen_t)(sizeof(flag)));
    if(ret == -1)
    {
      std::cout<<"FAILED to set socket option!"<<std::endl;
      exit(-1);
    }
    //bind    
    localaddr.sin_family = AF_INET;
    localaddr.sin_port = PORT;
    localaddr.sin_addr.s_addr = INADDR_ANY;
    int socketlen = sizeof(localaddr);
    // bzero() 会将内存块（字符串）的前n个字节清零;
    // s为内存（字符串）指针，n 为需要清零的字节数。
    // 在网络编程中会经常用到。
    // void bzero(void *s, int n);
    bzero(&(localaddr.sin_zero),8);
    //int ret_bind = bind(socket_fd,(struct sockaddr *)&localaddr,(socklen_t)(sizeof(struct sockaddr_in)));
    int bind_ret = bind(socket_fd,
        (struct sockaddr *)&localaddr,
        sizeof(struct sockaddr));
    if(bind_ret < 0)
    {
      std::cout<<"FAILED to bind addr!"<<std::endl;
      exit(-1);
    }
    int ret_listen = listen(socket_fd,backlog);
    if(ret_listen == -1)
    {
      std::cout<<"FAILED to listen!"<<std::endl;
      exit(-1);
    }
    pid_t pid = 0;
    for(;;){
      socklen_t sockaddr_len = sizeof(struct sockaddr_in);
      int accept_fd = accept(socket_fd,
      (struct sockaddr *) &remoteaddr, 
      &sockaddr_len);

      pid = fork();
      if(pid == 0){
      //子进程收发数据  
          for(;;)
          {
            //memset(in_buffer,0,MESSAGE_LEN);
            int recv_ret = recv(accept_fd,(void *)in_buffer,MESSAGE_LEN,0);
            if(recv_ret == 0)
            {
                break;
            }
            std::cout<<"recv : "<<in_buffer<<std::endl;
            send(accept_fd,(void*)in_buffer,MESSAGE_LEN,0);
          }
      
      std::cout<<"Close Client Connection"<<std::endl;
      close(accept_fd);
    }
    }
    if(pid!=0)close(socket_fd);
    return 0;
}

缺点：

  1. 以fork方式创建进程会一直占用系统资源。
  2. 在高并发情况下下创建子进程的时间开销大。

三、通过select实现高性能网络服务器

select实现高性能网络服务器其实是基于异步IO的思想。
异步IO，是指以事件触发的机制来对IO操作进行处理。
与多进程和多线程技术相比，异步IO技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些线程和进程，从而大大减小了系统的开销。

select步骤：

  1. 遍历文件描述符集中的所有描述符，找出有变化的描述符。
  2. 对于监听的socket和进行数据处理的socket要区别对待。
  3. socket必须要设置为非阻塞方式工作。

代码如下：

#include<iostream>
#include<stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include<string.h>
#include<netinet/in.h>
#include<unistd.h>
#include<fcntl.h>
#define max(a,b) ((a)>(b)?(a):(b))
#define PORT 8111
#define MESSAGE_LEN 1024
#define FD_SIZE 1024 //select默认只允许1024个连接
int main(int argc,char* argv[])
{
    int socket_fd = -1,accept_fd = -1;
    int on = 1;
    int curpos = -1;
    int backlog = 1000;
    int flag = 1;
    int max_fd = -1;
    int event = 0;
    int ret = -1;
    fd_set fd_sets;
    int accept_fds[FD_SIZE] = {-1};
    char in_buffer[MESSAGE_LEN] = {0,};
    struct sockaddr_in localaddr,remoteaddr;
    //create
    socket_fd = socket(AF_INET, SOCK_STREAM,0);
    if(socket_fd == -1)
    {
      std::cout<<"FAILED to CREATE SOCKET!"<<std::endl;
      exit(-1);
    }
    flag = fcntl(socket_fd,F_GETFL,0);
    //将fd设置为非阻塞
    fcntl(socket_fd,F_SETFL,flag | O_NONBLOCK);
    max_fd = socket_fd;
    ret = setsockopt(socket_fd,
                  SOL_SOCKET,
                  SO_REUSEADDR,
                  &flag,
                  (socklen_t)(sizeof(flag)));
    if(ret == -1)
    {
      std::cout<<"FAILED to set socket option!"<<std::endl;
      exit(-1);
    }
    //bind    
    localaddr.sin_family = AF_INET;
    localaddr.sin_port = PORT;
    localaddr.sin_addr.s_addr = INADDR_ANY;
    int socketlen = sizeof(localaddr);
    // bzero() 会将内存块（字符串）的前n个字节清零;
    // s为内存（字符串）指针，n 为需要清零的字节数。
    // 在网络编程中会经常用到。
    // void bzero(void *s, int n);
    bzero(&(localaddr.sin_zero),8);
    //int ret_bind = bind(socket_fd,(struct sockaddr *)&localaddr,(socklen_t)(sizeof(struct sockaddr_in)));
    int bind_ret = bind(socket_fd,
        (struct sockaddr *)&localaddr,
        sizeof(struct sockaddr));
    if(bind_ret < 0)
    {
      std::cout<<"FAILED to bind addr!"<<std::endl;
      exit(-1);
    }
    int ret_listen = listen(socket_fd,backlog);
    if(ret_listen == -1)
    {
      std::cout<<"FAILED to listen!"<<std::endl;
      exit(-1);
    }
    pid_t pid = 0;
    for(;;){
      FD_ZERO(&fd_sets);
      FD_SET(socket_fd,&fd_sets);
      
      for(int i = 0;i < FD_SIZE;i++)
      {
        //是一个有效的socket，才加入到fd_set中
        if(accept_fds[i] != -1){
          max_fd = max(max_fd,accept_fds[i]);
          FD_SET(accept_fds[i],&fd_sets);
        }
      }
      event = select(max_fd + 1,&fd_sets,NULL,NULL,NULL);
      if(event < 0){
         std::cout<<"Failed to use select!"<<std::endl;
         break;
      }else if(event == 0)
      {
        std::cout<<"Timeout!"<<std::endl;
        //由于没有设置超时时间，因此不可能等于零
        continue;
      }else{
        //该socket是否是监听的socket
        if(FD_ISSET(socket_fd,&fd_sets))
        {
           for(int i = 0;i < FD_SIZE;i++)
           {
              if(accept_fds[i] == -1) {
                curpos = i;
                break;
              }
           }
        
        socklen_t sockaddr_len = sizeof(struct sockaddr_in);
        accept_fd = accept(socket_fd,(struct sockaddr *) &remoteaddr, &sockaddr_len);
        flag = fcntl(accept_fd,F_GETFL,0);
        fcntl(accept_fd,F_SETFL,flag | O_NONBLOCK);
        //插入当前创建的accept_fd;
        accept_fds[curpos] = accept_fd;
        }
        //如果当前的socket不是用于监听的socket
        for(int i = 0;i<FD_SIZE;i++)
        {
          if(accept_fds[i] != -1 && FD_ISSET(accept_fds[i],&fd_sets))
          {
            memset(in_buffer,0,MESSAGE_LEN);
            int recv_ret = recv(accept_fds[i],(void *)in_buffer,MESSAGE_LEN,0);
            if(recv_ret == 0)
            {
              close(accept_fds[i]);
              break;
            }
            std::cout<<"recv : "<<in_buffer<<std::endl;
            send(accept_fds[i],(void*)in_buffer,MESSAGE_LEN,0);
          }
        }
      }

    }
    close(socket_fd);
    return 0;
}

四、通过epoll实现高性能网络服务器

关于epoll的优点请参考我的另一篇博客。

#include<iostream>
#include<stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include<string.h>
#include<netinet/in.h>
#include<sys/epoll.h>
#include<unistd.h>
#include<fcntl.h>
#define PORT 8111
#define MESSAGE_LEN 1024
#define TIMEOUT 500 // 500 ms 
#define MAX_EVENTS 20 //同一时刻的并发数

int main(int argc,char* argv[])
{
    int socket_fd = -1,accept_fd = -1;
    int on = 1;
    int curpos = 0;
    int backlog = 1000;
    int flag = 1;
    int ret = -1;
    int epoll_fd = -1;
    int event_number = -1;
    int recv_ret = -1;
    struct epoll_event ev,events[MAX_EVENTS];
    char in_buffer[MESSAGE_LEN] = {0,};
    struct sockaddr_in localaddr,remoteaddr;
    //create
    socket_fd = socket(AF_INET, SOCK_STREAM,0);
    if(socket_fd == -1)
    {
      std::cout<<"FAILED to CREATE SOCKET!"<<std::endl;
      exit(-1);
    }
    //需要将socket_fd设置为非阻塞
    flag=fcntl(socket_fd,F_GETFL,0);
    fcntl(socket_fd,F_SETFL,flag | O_NONBLOCK);

    ret = setsockopt(socket_fd,
                  SOL_SOCKET,
                  SO_REUSEADDR,
                  &flag,
                  (socklen_t)(sizeof(flag)));
    if(ret == -1)
    {
      std::cout<<"FAILED to set socket option!"<<std::endl;
      exit(-1);
    }
    //bind    
    localaddr.sin_family = AF_INET;
    localaddr.sin_port = PORT;
    localaddr.sin_addr.s_addr = INADDR_ANY;
    int socketlen = sizeof(localaddr);
    // bzero() 会将内存块（字符串）的前n个字节清零;
    // s为内存（字符串）指针，n 为需要清零的字节数。
    // 在网络编程中会经常用到。
    // void bzero(void *s, int n);
    bzero(&(localaddr.sin_zero),8);
    //int ret_bind = bind(socket_fd,(struct sockaddr *)&localaddr,(socklen_t)(sizeof(struct sockaddr_in)));
    int bind_ret = bind(socket_fd,
        (struct sockaddr *)&localaddr,
        sizeof(struct sockaddr));
    if(bind_ret < 0)
    {
      std::cout<<"FAILED to bind addr!"<<std::endl;
      exit(-1);
    }
    int ret_listen = listen(socket_fd,backlog);
    if(ret_listen == -1)
    {
      std::cout<<"FAILED to listen!"<<std::endl;
      exit(-1);
    }

    epoll_fd = epoll_create(256);
    ev.events = EPOLLIN; // 为了保证客户端的连接一定能被响应，我们使用水平触发
    ev.data.fd = socket_fd;
    //负责监听的socket
    epoll_ctl(epoll_fd,EPOLL_CTL_ADD,socket_fd,
             &ev);
    for(;;){
      event_number = epoll_wait(epoll_fd,events,MAX_EVENTS,TIMEOUT);
      for(int i=0;i<event_number;i++){
        //监听的socket,创建新链接
        if(events[i].data.fd==socket_fd){
           socklen_t sockaddr_len = sizeof(struct sockaddr_in);
           accept_fd = accept(socket_fd,
      (struct sockaddr *) &remoteaddr, 
      &sockaddr_len);
           flag=fcntl(accept_fd,F_GETFL,0);
           fcntl(accept_fd,F_SETFL,flag | O_NONBLOCK);
           ev.events = EPOLLIN | EPOLLET; //边缘触发
           ev.data.fd = accept_fd;
           epoll_ctl(epoll_fd,EPOLL_CTL_ADD,accept_fd,&ev);
        }else if(events[i].events & EPOLLIN)
        {
            //出现了输入的事件
            do{
                memset(in_buffer,0,MESSAGE_LEN);
                recv_ret = recv(events[i].data.fd,(void *)in_buffer,MESSAGE_LEN,0);//recv_ret表示收到消息的长度
                if(recv_ret == 0)
                {
                    std::cout<<"Quit Socket"<<std::endl;
                    close(events[i].data.fd);
                }
                if(recv_ret==MESSAGE_LEN)//进行阶段
                {
                  std::cout<<"maybe need to truncate data..."<<std::endl;
                }
            }while(ret < 0 && errno == EINTR);
            if(recv_ret < 0)
            {
              switch(errno){
                case EAGAIN: break;
                default: break; 
              }
            }
            if(recv_ret > 0){
              std::cout<<"recv : "<<in_buffer<<std::endl;
              send(events[i].data.fd,(void*)in_buffer,MESSAGE_LEN,0);
            }
        }
      }
    }
    close(socket_fd);
    return 0;
}

五、epoll + fork实现高性能网络服务器

一般在服务器上，CPU是多核的，上述epoll实现方式只使用了其中的一个核，造成了资源的大量浪费。因此我们可以将epoll和fork结合来实现更高性能的网络服务器。

但是在这种情况下，异步IO会出现惊群现象。我们可以通过在一个线程进行监听，加锁等方法解决。

六、通过异步事件的开源库来实现高性能网络服务器

一些著名的异步事件的开源库有

  1. libevent(Linux平台下基于epoll的开源库,用堆来管理超时事件)
  2. libevthp(基于libevent的http应用开发)
  3. libuv(Node.js正是基于此，在libev基础上进行调整，支持linux以外的几个平台)
  4. libev(改善了libevent的一些不合理之处，更加高效）

libevent重要的函数:

  1. event_base_new ( ~ epoll_create)
  2. event_base_dispatch ( ~ epoll_wait)
  3. event_new, event_add,event_del,event_free字面含义，这四个组成了epoll_ctl这个API
  4. evconnlistener_new_bind(把socket和事件的触发绑定到了一起)

总结

深入探究音视频开源库WebRTC中NetEQ音频抗网络延时与抗丢包的实现机制
dvlinker的技术专栏
04-24 1万+
深入探究音视频开源库WebRTC中NetEQ音频抗网络延时与抗丢包的实现机制
多人实时互动中的各个WebRTC流媒体服务器比较
WkpzScratch的博客
09-25 368
Jitsi Videobridge支持自适应码率调整、流媒体路由和模拟多路复用等功能，以提供高质量的视频传输和实时互动体验。Janus Gateway是一个开源的WebRTC服务器，它提供了广泛的功能和灵活性。在WebRTC中，流媒体服务器起着关键作用，负责处理媒体流的传输和处理。Kurento是一个功能强大的开源媒体服务器，专注于实时音视频处理和流媒体传输。它提供了丰富的媒体处理特性，如音视频录制、流媒体转码和实时特效等。Kurento支持多种流媒体协议，包括WebRTC、HTTP和RTMP等。
webrtc-server:开源WebRTC服务器列表
03-08
开源WebRTC服务器列表 2021年3月，我正在寻找可在自定义应用程序中使用的WebRTC服务器。 吉西 目前尚不清楚如何创建新房间。 参见 许可证：Apache 可以通过IFrame包含在自定义应用程序中。 OpenVidu React和Angular前端。 从2017年开始。比其他解决方案年轻 似乎更适合自定义应用程序（我的用例）。 血脑屏障 蓝色的大按钮。 完整的解决方案。 非常适合教育。 我想将其集成到自定义应用程序中并不容易。 对等JS Nextcloud谈话 相关图书馆 艾罗特克 许可证）。 看起来太低了。
epoll与fork
weixin_30432579的博客
09-28 391
使用epoll时，如果在调用epoll_create之后，调用了fork创建子进程，那么父子进程虽然有各自epoll实例的副本，但是在内核中，它们引用的是同一个实例。子进程向自己的epoll实例添加、修改和删除文件描述符时，是可以影响到父进程的epoll_wait的。所以会发生意想不到的问题，分情况看一下： 1：向子进程中的epoll实例添加描述符，描述...
开源WebRTC媒体服务器（转）
bingshanzhu的专栏
07-17 2620
什么是WebRTC服务器？ 在WebRTC的早期开始，该技术的主要卖点之一是它允许点对点（浏览器到浏览器）通信，几乎没有服务器的干预，服务器通常仅用于信令（比如用于连接代理）。 在这个应用阶段，一个专门的WebRTC媒体服务器的概念显得有点多余。 但是随着WebRTC应用场景变得复杂，比如在线视频会议，这个时候点对点通讯会遇到问题。下面，我将以视频会议为例尝试说明为什么媒体服务器很有用，它们通常提...
WebRTC网关服务器搭建：开源技术 vs 自行研发
weixin_33860737的博客
07-20 753
演讲 / 黄开宁整理 / 小极狗4月，即构WebRTC网关服务器正式上线，并实现了APP、微信小程序、WebRTC三端的连麦互通。WebRTC网关服务器的上线意味着即构的音视频能力可以全面支持网页端视频互动场景。作为实时音视频领域最火的开源技术，WebRTC 点对点的架构模式，无法支持大规模并发。如何在架构中引入服务端，一直是开发者关注的热点。5月20日，即构科技资深音视频架构师黄开宁在WebRT...
开源webrtc服务器对比
隔壁老王呀的专栏
03-30 6302
开源系统是目前市面上比较常见的，分别从服务器类型、编解码能力、文档的完整性和开发商来进行对比。大家都知道WebRTC的服务器模型有两种，分别是SFU和MCU，SFU实现的是简单转发的路由功能，而MCU可以提供更多扩展性的功能实现，而且MCU型的服务器往往包含SFU，所以MCU的实现难度较大。其次，文档的完整性也是非常重要的，因为对于开发者来说，文档具有非常重要的指导作用。最后是开发商，这个主要涉...
webRTC信令服务器实现音视频聊天
04-23
Socket.IO是一个实时应用程序框架，提供了一种简单、高效的方式来实现实时双向通信，非常适合用于WebRTC的信令传输。 1. **安装环境**：在开始之前，确保你已经安装了Node.js和npm（Node包管理器）。然后，创建一个...
webRTC（六）：webrtc信令服务器实现
2301_79098879的博客
04-20 1167
代码能力一定要注重，尤其是很多原理性的代码（之前两次让我写过Node中间件，Promise.all，双向绑定原理，被虐的怀疑人生）！**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。尽量从面试官的问题中表现自己知识的深度与广度，让面试官发现你的闪光点！尽量从面试官的问题中表现自己知识的深度与广度，让面试官发现你的闪光点！//给房间除自己以外所有人回。//给房间除自己以外所有人回。//给房间除自己以外所有人回。//给房间除自己以外所有人回。
WEBRTC-to-SIP:设置WEBRTC客户端和Kamailio服务器以调用SIP客户端
05-26
WEBRTC到SIP客户端和服务器 如何设置Kamailio + RTPEngine + TURN服务器以启用WebRTC客户端和旧版SIP客户端之间的呼叫。 默认情况下，此配置启用了IPv6。 此设置将桥接SRTP-> RTP和ICE-> nonICE，以使WebRTC客户端...
WebRTC媒体服务器&开源项目介绍
phymat.nico的专栏
10-19 257
https://blog.csdn.net/DONGHONGBAI/article/details/86709662 https://blog.csdn.net/freeabc/article/details/107162275 https://www.cnblogs.com/harlanc/p/9261484.html https://www.cnblogs.com/lidabo/p/12384633.html
推荐开源项目：aLiLua —— 超高效的epoll/kqueue web服务器
gitblog_00087的博客
05-10 370
推荐开源项目：aLiLua —— 超高效的epoll/kqueue web服务器 aliluaepoll/kqueue+lua based web server项目地址:https://gitcode.com/gh_mirrors/al/alilua 1、项目介绍 aLiLua是一款基于epoll（Linux）和kqueue（MacOS/BSD）事件模型的高性能Web服务器，内建对lua和coe...
高性能服务器————高性能服务器IO复用之select
陶超的博客
04-29 322
谈到IO复用就不得不了解一下，都有哪些关于IO复用的方法 IO复用的方法分为3种，这篇重点介绍select，至于其余的两种方法将会在下一篇介绍，考虑到篇幅和问题研究的专一性，这篇的重点就是分析select接口和原理，以及select使用的实例，如果对于为什么要使用IO复用以及IO复用的好处，可以翻看上一篇博客。 建议在了解这篇博客之前，先了解这些概念：阻塞、非阻塞、以及文件描述符的就绪状态、IO复...
webrtc服务器架构Mesh/MCU/SFU
sun007700的专栏
09-03 1225
webrtc笔记(3): 多人视频通讯常用架构Mesh/MCU/SFU https://www.cnblogs.com/yjmyzz/p/11182761.html
推荐开源项目：mediasoup v3 - 高效低延迟的WebRTC SFU框架
gitblog_00014的博客
05-11 726
推荐开源项目：mediasoup v3 - 高效低延迟的WebRTC SFU框架 mediasoupCutting Edge WebRTC Video Conferencing项目地址:https://gitcode.com/gh_mirrors/me/mediasoup 如果你正在寻找一个强大的、灵活的WebRTC SFU（Selective Forwarding Unit）解决方案，那么m...
webrtc学习--了解webrtc服务器
逝水流年
08-12 894
推荐一个零声学院免费教程，个人觉得老师讲得不错，分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，
【Linux】高性能服务器编程（二）——I/O复用之select
IT_Mitchell的博客
07-31 346
见上文高性能服务器编程（一）"多进程多线程和进程池线程池“ 在多进程多线程和进程池和线程池进行多并发操作的时候，进程或线程给一个客户端服务时，大部分是在阻塞等待客户端处理； 目标：当客户端发送来数据后，再分配线程或进程为其服务，这一次服务完成则进程或线程进入阻塞态等待下一次数据到达；所分配的进程和线程不仅仅只为一个客户端服务，而是为每一次数据服务。 这种方式就称为我们的I/O复用。 一、I...
多人实时互动之各WebRTC流媒体服务器比较
yinshipin007的博客
11-03 1020
随着网络基础设施的提高，音视频实时通信越来越成为人们日常生活和工作中必不可少的需求。2011年 WebRTC的出现，则更加速了这种需求变为现实的可能性。熟悉 WebRTC 的同学应该都知道，WebRTC规范只定义了实时通信中客户端的行为，而没有规范服务端（包括哪些信令、数据如何流转）的行为。所以，你可以使用WebRTC库方便的实现 1:1 实时通信，但对于多人实时互动，光依靠 WebRTC库显然就无法完成要求了。那我们该如何实现多人实时互动通信呢？
开源项目推荐：WebRTC-Swarm，构建强大的P2P网络
最新发布
gitblog_00198的博客
08-29 988
开源项目推荐：WebRTC-Swarm，构建强大的P2P网络 webrtc-swarmCreate a swarm of p2p connections using webrtc and a signalhub项目地址:https://gitcode.com/gh_mirrors/we/webrtc-swarm 在追求高效、直接数据传输的今天，我们发现了一颗璀璨的技术新星——WebRTC-Swa...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值