本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Libevent2是一个跨平台的网络事件处理库，支持Linux、Windows和Unix-like系统。它提供了统一的接口来处理套接字读写、连接完成等网络事件，并引入了多种优化策略来提升性能。本手册详细介绍了Libevent2的核心概念，包括事件模型、事件类型、API接口、多线程支持、定时器功能、HTTP和TCP服务器框架、内存管理和线程安全等。开发者通过学习本手册，可以熟练掌握libevent2来构建高效、可扩展的多线程网络应用程序，并能够获得社区的支持。 libevent2手册_libevent2_

1. 跨平台事件处理库libevent2简介

Libevent2是一个跨平台的事件处理库，其主要设计目的是简化网络编程的复杂性，提供一种快速、可扩展的方式来处理多种类型的事件，如文件描述符的可读/可写、定时器、信号等。该库支持多种操作系统，包括Unix、Linux以及Windows。它特别适用于需要同时处理多个网络连接和各种事件的高并发服务器应用。在本章节中，我们将对libevent2库的基本概念、特点及其在现代网络编程中的重要性进行浅入深出的探讨。通过本章学习，读者将对libevent2有一个全面的了解，并为深入学习后续章节打下坚实基础。

2. 非阻塞I/O事件模型介绍

非阻塞I/O模型是构建高性能网络服务的关键技术之一，而libevent2作为一款广泛使用的跨平台事件处理库，正是建立在这种模型之上的。在本章中，我们将深入探讨阻塞与非阻塞I/O模型之间的差异，以及libevent2的事件模型核心原理。

2.1 阻塞与非阻塞I/O模型对比

在深入理解libevent2之前，我们首先需要了解阻塞与非阻塞I/O模型的差异，这有助于理解为什么非阻塞模型在高性能网络应用中如此重要。

2.1.1 阻塞I/O模型的工作机制

阻塞I/O模型是最传统的I/O操作方式，在这种模式下，当应用程序请求I/O操作时，如果数据尚未到达或操作无法立即完成，应用程序将被阻塞。也就是说，应用程序必须等待I/O操作完成才能继续执行。例如，在读取网络数据时，如果请求的数据包还没到达，应用程序会一直等待，直到数据到来并处理完毕。

阻塞I/O的主要特点包括： - 操作同步执行：每个I/O请求都是同步的，一旦发起I/O操作，应用程序必须等待操作完成。 - 系统资源占用率高：在等待期间，线程无法进行其他任务，导致CPU资源被浪费。 - 系统扩展性差：随着连接数的增加，需要更多的线程来维持响应，这会增加系统的负载。

2.1.2 非阻塞I/O模型的优势分析

与阻塞I/O模型相比，非阻塞I/O模型提供了更优的系统性能和资源利用效率。在非阻塞I/O模型中，应用程序发起I/O请求后，如果数据未准备好，系统会立即返回控制权给应用程序，不会造成应用程序阻塞。

非阻塞I/O模型的主要优势包括： - 提高资源利用率：应用程序可以利用I/O等待时间来处理其他任务，提高CPU利用率。 - 增强系统可扩展性：由于应用程序不会被阻塞，因此可以服务更多的I/O请求，系统可以轻松扩展以适应更高的负载。 - 响应时间快：应用程序能够在I/O操作完成后立即得到通知，从而快速响应外部事件。

2.2 libevent2事件模型核心原理

libevent2是构建在非阻塞I/O模型之上的事件驱动库，它通过事件循环机制来高效地管理事件。

2.2.1 事件驱动的设计思想

事件驱动的设计思想是指在程序中不是通过轮询来检查状态，而是通过事件来通知程序某个操作已经完成。事件驱动的程序通常由事件循环、事件处理器和事件源组成。

事件驱动的核心组成部分有： - 事件循环：程序的主循环，负责不断检查事件队列并分发事件。 - 事件处理器：当特定事件发生时，关联的事件处理器会被调用。 - 事件源：可能产生事件的对象，如文件描述符、定时器或信号。

事件驱动的优点在于： - 高效性：不需要不断的检查资源状态，节省CPU资源。 - 易于扩展：程序模块化较好，便于添加新功能。 - 易于维护：由于逻辑清晰，代码更易于管理和更新。

2.2.2 事件循环机制的实现

libevent2的事件循环机制是其核心功能，能够高效地处理多种事件源，并在事件发生时调用相应的回调函数。事件循环主要由以下几个部分组成：

  • 事件注册：用户可以注册自己的事件处理器到事件循环中，指定感兴趣的事件类型，如读写事件或信号。
  • 事件检测：事件循环周期性地检查系统资源，如文件描述符的状态变化，或者是否有定时器到期。
  • 事件分发：当检测到事件时，事件循环会调用相应的事件处理器。
  • 事件处理：在事件处理器中，用户可以执行如读写数据等操作。

以下是一个简单的事件循环伪代码，展示了libevent2如何实现事件循环： 

event_base *base = event_base_new();
struct event *ev = event_new(base, /* file descriptor */, EV_READ | EV_PERSIST, callback_function, /* user data */);
event_add(ev, /* timeout */);
event_base_dispatch(base);

逻辑分析： 1. event_base_new 创建一个新的事件基础结构。 2. event_new 创建一个新的事件并注册到事件基础结构中，同时指定其回调函数。 3. event_add 将事件加入到事件循环中，并可指定超时。 4. event_base_dispatch 开始事件循环，直到事件基础结构被销毁。

参数说明： - event_base_new 函数用于创建一个新的事件循环基础结构。 - event_new 函数用于创建一个事件，并且关联到指定的文件描述符和事件处理器。 - EV_READ 和 EV_WRITE 分别指明了事件的类型为读和写。 - EV_PERSIST 表示该事件是持久的，即使触发后也会重新加入到事件循环中。 - callback_function 是事件触发时被调用的函数，它必须符合libevent的回调函数签名。

在实际开发中，理解事件循环的工作原理，对于优化网络服务性能至关重要。通过合理地使用libevent2的事件循环机制，可以构建出高性能、低延迟的应用程序。

通过本章节的介绍，我们应该对非阻塞I/O模型与libevent2事件模型有了更深入的理解。在下一章中，我们将进一步探索libevent2的事件基础结构及其处理函数的具体使用方法。

3. 事件基础结构与事件处理函数

3.1 事件基础结构详解

3.1.1 事件的组成和类型

在libevent2中，一个事件（event）是由其所属的文件描述符（file descriptor）、事件类型以及事件处理函数组成。一个事件可以是以下几种类型之一：

  • READ事件 ：当文件描述符上的读缓冲区有数据可读时触发。
  • WRITE事件 ：当文件描述符上的写缓冲区可以写入数据时触发。
  • 异常事件 ：当文件描述符上发生异常情况时触发，如断开连接。

事件的类型决定了何时该事件会被 libevent2 放入事件循环中进行处理。例如，一个监听在套接字上的READ事件会在连接的另一端有数据发送过来时被处理。

事件的组成还包括了优先级和标志位，这些可以用来指定事件的一些特殊行为，如是否边缘触发或者水平触发。

3.1.2 事件队列的工作原理

事件库通常会将待处理的事件放入一个队列中，称为事件队列（event queue）。当事件发生时，事件库会根据事件的类型和队列的组织方式将事件加入队列中。libevent2使用的是基于优先级的事件队列，确保了高优先级的事件能够被优先处理。

事件队列中的事件会被libevent2的事件循环（event loop）统一管理。事件循环是一个无限循环，它会不断检查事件队列并执行事件处理函数。事件循环的效率直接影响了整个应用程序的性能。

事件队列通常还会使用一些数据结构（如红黑树）来组织事件，这样可以确保对事件的插入、查找和删除操作都能够在对数时间内完成，保证了事件处理的效率。

3.2 事件处理函数的应用

3.2.1 常用事件处理函数介绍

事件处理函数是与事件关联的函数，当事件被触发时，相应的事件处理函数会被执行。libevent2提供了一系列的API来注册、启用和禁用事件，以及设置和修改事件的回调函数。

最常用到的API包括：

  • event_new() : 创建一个新的事件。
  • event_add() : 将事件添加到事件循环。
  • event_del() : 从事件循环中删除一个事件。
  • event_active() : 手动激活事件，这可以用来处理非标准的事件触发。

事件处理函数的原型一般如下： 

void callback_function(int fd, short events, void *arg);
  • fd 是文件描述符。
  • events 包含了触发该事件的具体类型。
  • arg 是可以传递给回调函数的用户自定义数据。

3.2.2 回调函数的使用实例

回调函数是事件处理的核心，下面是一个简单的回调函数使用示例，当一个套接字（socket）可读时，这个函数会被调用： 

void read_callback(int fd, short events, void *arg) {
    char buf[1024];
    int n = read(fd, buf, sizeof(buf));

    if (n > 0) {
        // 处理接收到的数据
    } else if (n == 0) {
        // 处理连接断开的情况
    } else {
        // 处理读取错误的情况
    }
}

然后，你需要在代码中注册这个回调函数，以便当对应的事件发生时，libevent2 能够调用它。注册的过程如下： 

struct event *ev;
ev = event_new(base, fd, EV_TIMEOUT | EV_READ, read_callback, (void*)arg);
event_add(ev, NULL);

在上述代码中， base 是 libevent2 事件基础结构， fd 是文件描述符， EV_TIMEOUT | EV_READ 是事件的类型， read_callback 是回调函数， arg 是传递给回调函数的参数。

这个过程创建了一个事件，并将其加入到事件循环中。当有数据可读时，libevent2 会调用 read_callback 函数，并将数据处理逻辑放入其中。

在实际应用中，回调函数通常需要处理各种边缘情况，并且要高效且稳定，因为它们是事件驱动程序的核心。此外，如果程序需要处理多个事件，合理地组织回调函数是很重要的，以避免代码的混乱和错误的发生。

4. 多种事件类型支持及C语言API接口使用方法

4.1 libevent2支持的事件类型

4.1.1 读写事件的处理

libevent2提供了对读写事件的高效处理机制，它允许开发者对文件描述符的读写操作进行监控。当文件描述符上发生可读或可写事件时，libevent会触发相应的事件处理器。这里是一个简单的例子，展示如何使用libevent2处理文件描述符的读写事件： 

#include <event2/event.h>

void read_callback(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *arg) {
    // 当有读事件发生时的处理代码
}

void write_callback(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *arg) {
    // 当有写事件发生时的处理代码
}

int main(void) {
    struct event_base *base;
    struct evconnlistener *listener;

    base = event_base_new(); // 创建一个事件循环基础结构
    listener = evconnlistener_new_bind(base, read_callback, NULL, LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1, 
                                       (struct sockaddr*)&address, sizeof(address)); // 监听读事件

    evconnlistener_enable_write_cb(listener); // 开启写事件监听

    event_base_dispatch(base); // 进入事件循环

    evconnlistener_free(listener); // 释放监听器
    event_base_free(base); // 释放事件基础结构

    return 0;
}

上述代码中， evconnlistener_new_bind 创建了一个监听器，用于监听可读事件。通过 evconnlistener_enable_write_cb 函数，监听器还能同时处理写事件。这样就构建了一个可以同时处理读写事件的事件循环。

4.1.2 信号事件的集成

信号事件的集成允许libevent2处理由操作系统发送的信号。信号事件与读写事件类似，也能加入到事件循环中。以下是如何集成信号事件的一个例子： 

#include <signal.h>
#include <event2/event.h>

void signal_callback(evutil_socket_t fd, short events, void *arg) {
    // 信号事件的处理代码
    struct event *signal_event = arg;

    // 停止监听信号
    event_del(signal_event);
    // 关闭信号事件的文件描述符
    event_free(signal_event);
}

int main(void) {
    struct event_base *base;
    struct event *signal_event;

    base = event_base_new(); // 创建事件循环基础结构

    // 创建一个信号事件监听器
    signal_event = evsignal_new(base, SIGINT, signal_callback, signal_event);
    event_add(signal_event, NULL); // 将信号事件加入到事件循环中

    event_base_dispatch(base); // 进入事件循环

    event_free(signal_event); // 清理事件
    event_base_free(base); // 清理事件基础结构

    return 0;
}

在这段代码中，我们创建了一个信号事件 signal_event ，并且将其与 SIGINT 信号关联起来。当信号事件被触发时， signal_callback 函数会被调用。信号事件与文件描述符事件一样，可以被加入到事件循环中，由libevent管理。

4.2 C语言API接口详解

4.2.1 API接口分类和功能

libevent2的API接口可以大致分为三类：事件处理相关的接口、网络连接相关的接口和定时器相关的接口。这些API的详细功能如下：

  • 事件处理API ：这些API负责注册、修改和删除事件处理器。主要包括 event_new , event_add , event_active 和 event_del 。
  • 网络连接API ：这类API用于创建和管理网络连接，例如 evconnlistener_new 和 evconnlistener_disable 。
  • 定时器API ：定时器相关的API用于创建和管理定时器事件，比如 evtimer_new 和 evtimer_add 。

4.2.2 API接口使用示例及注意事项

下面提供了一个使用libevent2 API接口创建和使用事件处理器的例子： 

#include <event2/event.h>

void callback(evutil_socket_t fd, short what, void *arg) {
    // 执行对应事件发生时的操作
}

int main() {
    struct event_base *base;
    struct event *ev;

    base = event_base_new(); // 创建一个新的事件基础结构

    ev = event_new(base, -1, EV_TIMEOUT|EV_PERSIST, callback, NULL); // 创建一个事件处理器
    struct timeval tv = {1, 0}; // 设置超时时间1秒
    event_add(ev, &tv); // 将事件添加到基础结构中
    event_active(ev, 0, 0); // 激活事件

    event_base_dispatch(base); // 进入事件循环等待事件发生

    event_free(ev); // 清理事件处理器
    event_base_free(base); // 清理事件基础结构

    return 0;
}

在使用libevent2时，有一些注意事项需要遵循：

  • 事件循环控制 ：确保在任何时候只有一个事件循环在运行。
  • 内存管理 ：对创建的事件处理器和定时器使用 event_free 进行释放，避免内存泄漏。
  • 线程安全 ：在多线程程序中正确使用libevent2的API，确保线程安全。在启动事件循环前使用 event_base_loopexit 来优雅退出事件循环。
  • 资源管理 ：确保在程序退出前正确释放所有资源，避免资源泄漏。

通过上述章节内容，我们了解了libevent2支持的事件类型以及如何使用C语言API接口。在接下来的章节中，我们将探讨如何在多线程环境下使用libevent2，以及如何利用其提供的API接口。

5. 多线程环境下的使用和线程API

5.1 libevent2的多线程支持

5.1.1 多线程环境的配置和初始化

在使用libevent2进行多线程开发之前，开发者必须熟悉其多线程环境的配置和初始化过程。libevent2从2.0版本开始支持多线程，这使得它可以在多线程应用程序中安全地使用。要启用libevent2的多线程支持，首先需要在编译时定义 EVENT_FINALIZEлейBOTH 和 EVENT_use_pthreads 。这两个宏确保libevent2的内部结构和函数在多线程环境中正确执行。

在应用程序中，初始化libevent2的多线程支持通常需要调用 event_init() 或者 event_base_new_with_config() ，后者允许更细致的配置。例如： 

#include <event2/event.h>

struct event_base *base;

// 在线程安全的上下文中初始化libevent
base = event_base_new();
if (!base) {
    // 处理错误
}

初始化函数会配置一些关键的线程安全机制，比如事件循环的线程锁。开发者还应当注意，在libevent2中，每个线程使用 event_base_loop() 运行自己的事件循环是安全的。事实上，libevent2在内部会为每个线程创建一个独立的事件循环，这样就可以避免锁竞争，提高性能。

5.1.2 线程同步机制的选择和应用

在多线程编程中，线程同步机制是保证数据一致性的关键。libevent2为开发者提供了多种线程同步机制，包括互斥锁( event_mutex )、条件变量( event_cond )和信号量( event_sem )。这些同步机制在libevent2中都是线程安全的，并且可以方便地与libevent2的事件循环集成。

选择合适的同步机制非常依赖于特定的应用场景。例如：

  • 互斥锁(event_mutex) ：当多个线程需要访问共享资源时，可以使用互斥锁来保证任何时候只有一个线程可以访问该资源。
  • 条件变量(event_cond) ：条件变量通常与互斥锁一起使用，以等待某个条件为真，而不需要不断轮询检查。
  • 信号量(event_sem) ：信号量适用于控制对有限资源的访问数量。

使用这些同步机制时，开发者必须确保在完成操作后，及时释放锁或信号量。否则，可能会导致死锁或其他线程同步问题。

下面是一个使用互斥锁保护共享资源的简单例子： 

#include <event2/event.h>
#include <pthread.h>
#include <stdio.h>

struct event_base *base;
pthread_mutex_t mutex;

void thread_func(void *arg) {
    // 获取锁
    pthread_mutex_lock(&mutex);
    printf("Thread has acquired the lock.\n");
    // 临界区开始
    // ...访问共享资源...
    // 临界区结束
    printf("Thread is releasing the lock.\n");
    // 释放锁
    pthread_mutex_unlock(&mutex);
}

int main() {
    pthread_t thread1, thread2;

    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);

    // 创建线程
    pthread_create(&thread1, NULL, thread_func, NULL);
    pthread_create(&thread2, NULL, thread_func, NULL);

    // 等待线程完成
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 清理互斥锁
    pthread_mutex_destroy(&mutex);
}

在多线程编程时，应谨慎使用这些同步机制，合理安排它们在代码中的位置，以免造成不必要的性能开销。

5.2 线程API的使用方法

5.2.1 线程安全的事件操作

在libevent2中，大多数事件操作都是线程安全的，包括创建、销毁事件等。不过，在特定情况下，进行事件操作时需要考虑当前线程是否已经绑定了某个事件循环。

例如，当开发者需要在非事件循环线程中创建事件对象，并希望在事件循环线程中处理该事件时，应该使用事件基的线程安全API，比如 event_assign() 或 event_base_once() 。这些API会自动处理线程间事件的传递和注册。

下面是一个创建并绑定事件到特定事件循环的示例： 

#include <event2/event.h>

struct event_base *base;
struct event *ev;

// 获取默认的事件基对象
base = event_base_get_default();
ev = event_new(base, -1, EV_TIMEOUT|EV_PERSIST, callback_function, NULL);

// 在其他线程中进行事件操作
if (pthread_mutex_lock(&lock)) {
    // 处理错误
}
event_active(ev, 0, 0);
if (pthread_mutex_unlock(&lock)) {
    // 处理错误
}

请注意，在多线程环境中，一旦事件被绑定到某个事件循环，其他线程就不应该再尝试将这个事件绑定到另一个循环，或者更改事件的配置。

5.2.2 线程间通信和事件分发

libevent2提供了高效的线程间通信机制，使得事件可以在多个线程的事件循环之间正确地分发。线程间通信机制是构建高度可扩展和响应迅速的网络应用程序的基础。

线程间的通信主要是通过 event_base_loop() 函数在不同线程中调用实现的。该函数允许事件在多个线程上被激活和处理。在某些情况下，可能需要从一个线程向另一个线程的事件循环发送消息。libevent2提供了一些方法来实现这种线程间通信，例如使用 event_base_once() 函数在线程间调度一个一次性的事件。

除了以上提到的函数，libevent2还提供了一个重要的线程API event_base_loopexit() ，它允许开发者从另一个线程退出事件循环，这样就实现了从一个线程向另一个线程的事件循环发送信号。

下面是一个简单的线程间通信的例子，展示了如何使用 event_base_once() 来在事件循环中执行线程安全的操作： 

#include <event2/event.h>

void thread_exit_event_base(struct event_base *base) {
    // 设置一个一次性事件来安全地退出另一个线程的事件循环
    event_base_once(base, -1, EV_TIMEOUT|EV_PERSIST, event_base_exit, base, NULL);
}

// 在一个线程中启动事件循环
void *thread_function(void *arg) {
    struct event_base *base = (struct event_base *)arg;
    event_base_dispatch(base);
    return NULL;
}

int main(int argc, char **argv) {
    struct event_base *base = event_base_new();

    // 创建一个新线程来运行事件循环
    pthread_t loop_thread;
    pthread_create(&loop_thread, NULL, thread_function, base);

    // 当需要从另一个线程退出事件循环时
    thread_exit_event_base(base);

    // 等待事件循环线程退出
    pthread_join(loop_thread, NULL);

    event_base_free(base);
    return 0;
}

在上述代码中， event_base_once() 函数被用来在其他线程中安全地调度退出事件循环的事件。这是处理线程间事件分发的典型用法。

随着应用程序规模的扩大和复杂性的增加，理解和应用线程API对于保持高性能和稳定性至关重要。libevent2的事件驱动模型为开发者提供了一套强大的工具集，可以在保证线程安全的同时，实现复杂的并发场景。

6. 事件调度策略和性能优化

6.1 事件调度策略的选择与实现

事件调度策略是libevent2库中用于管理事件循环、确定事件处理优先级和时间管理的核心机制。正确的调度策略可以极大提高程序处理事件的效率和响应性。

6.1.1 调度策略的种类和适用场景

libevent2提供了多种调度策略，每种策略适用于特定的场景： - EVLOOP_NONBLOCK ：非阻塞模式，当没有事件时，循环立即返回。适用于需要频繁检查是否有新事件到来的场景。 - EVLOOP_NO_EXIT_ON_EMPTY ：当事件队列为空时，不退出事件循环。适用于需要长时间运行的服务器程序。 - EVLOOP_ONE_SHOT ：单次事件循环模式，处理完事件后退出循环，适用于只需要一次性执行的任务。

自定义调度策略允许开发者根据实际需求设计事件循环的行为。

6.1.2 自定义调度策略的方法

自定义调度策略需要深入了解事件循环的工作流程。可以通过实现一个 event_base_loop 的回调函数来修改默认行为。例如，为了解决某些特殊问题，需要在每次事件循环迭代后执行特定的代码，可以如下实现： 

static int my_event_loop_callback(struct event_base *base) {
    // 执行特定操作
    my_custom_code();
    return 1; // 返回非零值表示继续事件循环，0表示退出
}

event_base_loop(base, EVLOOP_NO_EXIT_ON_EMPTY | EVLOOP_ONE_SHOT);
event_base_set_loop_callback(base, my_event_loop_callback);

上述代码片段展示了如何为事件循环设置自定义回调。

6.2 性能优化技巧

libevent2作为一个事件驱动的库，性能优化是提升应用程序性能的重要手段。在理解事件调度策略的基础上，性能优化应聚焦于事件循环性能分析和性能瓶颈识别。

6.2.1 事件循环性能分析

事件循环性能分析可以通过监控事件调度器的活动来进行。例如，使用 event_base_get_locks 函数获取当前事件基础结构使用的锁，并分析锁的竞争情况： 

event_base_get_locks(base, locks);
for (i = 0; i < n_locks; ++i) {
    fprintf(stderr, "%s: count=%d, held=%d\n",
        locks[i].name, locks[i].count, locks[i].held);
}

通过上述代码，可以获取事件循环中所有锁的信息，从而分析是否存在瓶颈。

6.2.2 性能瓶颈的识别与解决

性能瓶颈可能出现在多个方面，如锁的争用、资源的过度分配、事件处理函数的低效率等。解决这些瓶颈通常需要结合具体的应用场景和性能分析数据，采取针对性的措施。例如，对于锁争用，可以考虑使用更精细的锁机制，或是减少对共享资源的访问。对于事件处理函数，可以通过实现更高效的数据处理算法或优化代码逻辑来提高性能。

在性能优化过程中，务必详细记录优化前后的性能数据，以便评估优化措施的效果，并根据需要进行调整。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Libevent2是一个跨平台的网络事件处理库，支持Linux、Windows和Unix-like系统。它提供了统一的接口来处理套接字读写、连接完成等网络事件，并引入了多种优化策略来提升性能。本手册详细介绍了Libevent2的核心概念，包括事件模型、事件类型、API接口、多线程支持、定时器功能、HTTP和TCP服务器框架、内存管理和线程安全等。开发者通过学习本手册，可以熟练掌握libevent2来构建高效、可扩展的多线程网络应用程序，并能够获得社区的支持。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

Logo
乐奇 Rokid 开放社区

更多推荐

cover

TestStar | AIUI 数据库客户端测试Case执行实录

avatar 乐奇 Rokid 开放社区
cover

AR巡检哪家好

avatar 乐奇 Rokid 开放社区
cover

具身智能 | Ego数采设备与选择标准一文理清，避开无效采集

avatar 乐奇 Rokid 开放社区