libuv学习-管道

admin管理员组

文章数量:1531666

一. 管道的例子

/*
    libuv pipe sample
*/
#include <uv.h>
#include <stdio.h>
#include <stdlib.h>
void on_pipe_read(uv_stream_t* pipe, ssize_t nread, const uv_buf_t* buf) {
    if (nread < 0) {
        if (nread == UV_EOF) {
            // End of file
        } else {
            // Error handling
        }
    } else if (nread > 0) {
        // Data is available in buf->base, with length nread
    }

    // Remember to free the buffer
    if (buf->base) {
        free(buf->base);
    }
}

void on_pipe_write(uv_write_t* req, int status) {
    if (status < 0) {
        // Error handling
    }

    // Remember to free the write request
    free(req);
}

int main() {
    uv_loop_t* loop = uv_default_loop();

    uv_pipe_t pipe;
    uv_pipe_init(loop, &pipe, 0);

    // Create a pipe for reading and writing
    int r = uv_pipe_open(&pipe, 0);
    if (r != 0) {
        // Error handling
        return r;
    }

    // Read from the pipe
    uv_read_start((uv_stream_t*)&pipe, [](uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
        buf->base = (char*)malloc(suggested_size);
        buf->len = suggested_size;
    }, on_pipe_read);

    // Write to the pipe
    uv_write_t* write_req = (uv_write_t*)malloc(sizeof(uv_write_t));
    uv_buf_t buf = uv_buf_init("Hello, world!", 13);
    uv_write(write_req, (uv_stream_t*)&pipe, &buf, 1, on_pipe_write);

    // Run the event loop
    uv_run(loop, UV_RUN_DEFAULT);

    // Clean up
    uv_close((uv_handle_t*)&pipe, nullptr);
    uv_loop_close(loop);

    return 0;
}

二. 代码解析

结构体

uv_pipe_t

struct uv_pipe_s {
  UV_HANDLE_FIELDS
  UV_STREAM_FIELDS
  int ipc; /* non-zero if this pipe is used for passing handles */
  UV_PIPE_PRIVATE_FIELDS
};

typedef struct uv_pipe_s uv_pipe_t;

这个结构体代表了一个管道（pipe）。管道是一种在进程间进行通信的方法，可以用于在不同的进程之间传递数据。

uv_write_t

struct uv_write_s {
  UV_REQ_FIELDS
  uv_write_cb cb;
  uv_stream_t* send_handle; /* TODO: make private and unix-only in v2.x. */
  uv_stream_t* handle;
  UV_WRITE_PRIVATE_FIELDS
};

typedef struct uv_write_s uv_write_t;

这个结构体用于表示写入操作的请求。用于发起向流（例如管道、套接字等）写入数据的异步请求。

函数

uv_pipe_init

int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc);
这个函数 用于初始化管道（pipe）
形参解析：
loop：一个指向 libuv 事件循环的指针，表示要将管道初始化到哪个事件循环上。
handle：一个指向 uv_pipe_t 结构体实例的指针，表示要初始化的管道。
ipc：一个整数，表示是否启用进程间通信（Inter-Process Communication，IPC）功能。如果传递非零值，则表示启用 IPC 功能；如果传递 0，则表示不启用 IPC 功能。

uv_pipe_open

int uv_pipe_open(uv_pipe_t* handle, uv_file file);
这个函数用于将一个已有的文件描述符（例如由其他进程创建的管道）绑定到一个 uv_pipe_t 结构体实例上。
形参解析：
handle：一个指向已初始化的 uv_pipe_t 结构体实例的指针，表示要打开的管道。
file：一个文件描述符，表示要绑定到管道的已有的文件描述符。

uv_read_start

int uv_read_start(uv_stream_t* stream, uv_alloc_cb alloc_cb, uv_read_cb read_cb);

这个函数用于启动从流（stream）中读取数据。用于设置 libuv 在流上开始异步读取操作的条件和回调函数。
形参解析：
stream：一个指向已初始化的 uv_stream_t 结构体实例的指针，表示要开始读取数据的流。
alloc_cb：一个回调函数，用于分配内存以存储接收到的数据。它的原型为 void (alloc_cb)(uv_handle_t handle, size_t suggested_size, uv_buf_t* buf)。
read_cb：一个回调函数，用于处理接收到的数据。它的原型为 void (read_cb)(uv_stream_t stream, ssize_t nread, const uv_buf_t* buf)。

uv_write

int uv_write(uv_write_t* req, uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb);

这个函数用于向流（stream）中写入数据。用于发起一个异步写入操作，将数据写入到指定的流中。
形参解析：
req：一个指向 uv_write_t 结构体实例的指针，表示要发起的写入请求。
handle：一个指向已初始化的 uv_stream_t 结构体实例的指针，表示要写入数据的流。
bufs：一个 uv_buf_t 数组，表示要写入的数据缓冲区。
nbufs：表示要写入的数据缓冲区的数量。
cb：一个回调函数，表示写入操作完成后要执行的回调函数。它的原型为 void (cb)(uv_write_t req, int status)。

参考

libuv官方文档

https://libuv-docs-chinese.readthedocs.io/zh/latest/

chatgpt

https://chat.openai/

本文标签： 管道libuv