✨ v0.1.8 - 实验性发布

gorust:
Go 风格并发，Rust 极致性能

一个轻量级、高性能的并发运行时，将 Go 语言的并发模型与 Rust 的零成本抽象完美结合。提供熟悉的 goroutines、channels 和 select 原语，让 Rust 并发编程更简单。

快速开始 GitHub 仓库

核心模块

channel, scheduler, timer...

15+

示例程序

examples/

M:N

调度模型

工作窃取算法

~3MB

内存占用

基础运行时

为什么选择 gorust？

🚀

Goroutines

轻量级协程，类似 Go 的 goroutine。使用 go() 函数轻松创建并发任务，自动管理生命周期。

📡

Channels

支持有缓冲和无缓冲通道，实现 goroutine 间的通信。提供 send() 和 recv() 方法。

🎯

Select 宏

类似 Go 的 select 语句，支持多路复用通道操作。使用 select! 宏或函数式 API。

⏱️

定时器

提供 sleep() 和 sleep_ms() 函数，支持协程级别的睡眠，不阻塞其他协程。

🔒

同步原语

WaitGroup、Mutex、RWMutex、AtomicCounter、Once 等完整的同步工具集合。

🌐

网络轮询器

基于 mio 的事件驱动网络轮询器，支持异步 I/O 操作，高效处理网络连接。

📊

工作窃取调度器

M:N 调度模型，支持工作窃取算法，充分利用多核 CPU，自动负载均衡。

🔧

过程宏

#[runtime]、select!、make_chan! 等宏，提供类 Go 语法。

🛡️

Ctrl-C 信号处理

内置信号处理，优雅关闭运行时，确保所有 goroutine 安全退出。

📄 代码示例

use gorust::{go, runtime, Runtime, yield_now, sleep};

#[runtime]
fn main() {
    // 创建 goroutine
    go(|| {
        println!("Hello from goroutine!");
    });

    // 带参数的 goroutine
    for i in 0..5 {
        go(move || {
            println!("Goroutine {} is running", i);
            yield_now();
            println!("Goroutine {} done", i);
        });
    }

    println!("Active goroutines: {}", Runtime::active_goroutines());
}

use gorust::{go, runtime, make_chan};

#[runtime]
fn main() {
    // 创建无缓冲通道
    let ch = make_chan!(i32);
    
    // 发送端
    let ch_snd = ch.clone();
    go(move || {
        ch_snd.send(42).unwrap();
        println!("Value sent!");
    });

    // 接收端
    let ch_rcv = ch.clone();
    go(move || {
        let value = ch_rcv.recv().unwrap();
        println!("Received: {}", value);
    });

    // 有缓冲通道
    let ch2 = make_chan!(String, 10);
    ch2.send("Hello".to_string()).unwrap();
    let received = ch2.recv().unwrap();
}

use gorust::{go, runtime, make_chan, select, sleep};
use std::time::Duration;

#[runtime]
fn main() {
    let ch1 = make_chan!(i32);
    let ch2 = make_chan!(String);

    // 使用 select! 宏
    select! {
        recv(ch1) -> msg => {
            println!("Got from ch1: {:?}", msg);
        }
        recv(ch2) -> msg => {
            println!("Got from ch2: {:?}", msg);
        }
        default => {
            println!("No channel ready");
        }
    }

    // 使用函数式 API
    let result = select_builder()
        .recv(&ch1, |msg| println!("Got: {:?}", msg))
        .timeout(Duration::from_secs(2), || println!("Timeout!"))
        .execute();
}

use gorust::{go, runtime, sleep};
use gorust::sync::{WaitGroup, AtomicCounter};
use std::time::Duration;

#[runtime]
fn main() {
    // WaitGroup 示例
    let wg = WaitGroup::new();
    for i in 0..3 {
        wg.add(1);
        let wg_clone = wg.clone();
        go(move || {
            println!("Task {} starting", i);
            sleep(Duration::from_secs(i));
            println!("Task {} finished", i);
            wg_clone.done();
        });
    }
    wg.wait();

    // AtomicCounter 示例
    let counter = AtomicCounter::new();
    for _ in 0..100 {
        let c = counter.clone();
        go(move || {
            c.increment();
        });
    }
    println!("Count: {}", counter.get());
}

架构设计

调度器 (Scheduler)

M:N 调度模型，多个工作线程（Processor）各自维护本地队列，支持工作窃取算法实现负载均衡。

协程 (Goroutine)

轻量级用户态协程，初始栈仅 2KB，自动栈增长。协程由调度器管理，非操作系统线程。

通道 (Channel)

支持有缓冲和无缓冲通道，内部使用环形队列实现，提供阻塞和非阻塞的 send/recv 操作。

定时器 (Timer)

分层定时器实现，基于最小堆管理超时事件，支持协程级别的 sleep 而不阻塞其他协程。

网络轮询器 (Netpoller)

基于 mio 的事件驱动 I/O 多路复用，支持 TCP/UDP 异步操作，高效处理网络连接。

同步原语 (Sync)

提供 WaitGroup、Mutex、RWMutex、Pool、Context 等 Go 风格的同步工具。

核心 API

API	类型	描述
`go(fn)`	函数	创建新的 goroutine
`#[runtime]`	宏	初始化运行时并管理生命周期
`make_chan!(T)`	宏	创建无缓冲通道
`make_chan!(T, cap)`	宏	创建有缓冲通道
`select! { ... }`	宏	多路复用通道操作
`sleep(duration)`	函数	协程级睡眠
`yield_now()`	函数	主动让出 CPU
`Runtime::wait_for_all()`	函数	等待所有协程完成

🚀 快速开始

# 添加依赖
[dependencies]
gorust = { git = "https://github.com/WLmutou/gorust.git" }

# 创建一个简单的并发程序
cargo new my_gorust_app
cd my_gorust_app

GitHub 仓库阅读文档 →

gorust: Go 风格并发，Rust 极致性能