1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Rust 的借用规则在编译期就拒绝了数据竞争
fn main() {
    let mut data = vec![1, 2, 3];

    // 尝试同时拥有两个可变引用？编译期报错！
    let r1 = &mut data;
    let r2 = &mut data; // ❌ 编译器：你小子想干嘛？想制造数据竞争吗？

    r1.push(4);
}

1
2
3
4
5
6
7
8
9

error[E0499]: cannot borrow `data` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut data;
  |                 ---- first mutable borrow occurs here
5 |     let r2 = &mut data;
  |                 ^^^^^ second mutable borrow occurs here
6 | }
  |   first borrow might be used here, when `r1` is dropped

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 这段代码展示如何使用平台特定的模块
use std::path::Path;

fn main() {
    // Unix 系统
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        // 在 Unix 上，我们可以精细控制文件权限
        let path = Path::new("/tmp/test.txt");
        println!("Unix 平台：文件权限系统支持一切尽在掌握");
    }

    // Windows 系统
    #[cfg(windows)]
    {
        println!("Windows 平台：我们用 ACL，不用 chmod");
    }

    // 跨平台的文件元信息
    let metadata = Path::new("Cargo.toml").metadata().unwrap();
    println!("文件大小：{} 字节", metadata.len());
    println!("是否为文件：{}", metadata.is_file());
    println!("是否为目录：{}", metadata.is_dir());
}

1
2
3

文件大小：1256 字节
是否为文件：true
是否为目录：false

1
2
3

# Cargo.toml
[dependencies]
libc = "0.2"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 使用 libc 直接调用 Unix 系统调用
use libc::{c_char, c_int, c_void, size_t, strlen};
use std::ffi::CString;

fn main() {
    // 经典的 puts 系统调用（写字符串到标准输出）
    let message = CString::new("你好，Unix 系统调用！").unwrap();
    unsafe {
        libc::puts(message.as_ptr());
    }

    // 获取当前进程的 PID（Process ID）
    let pid = unsafe { libc::getpid() };
    println!("当前进程 PID: {}", pid);

    // 获取当前进程的真实用户 ID
    let uid = unsafe { libc::getuid() };
    println!("真实用户 ID (UID): {}", uid);

    // 使用 strlen——C 字符串长度计算
    let c_str = CString::new("Rust 调用 C 就是这么直接").unwrap();
    let len = unsafe { strlen(c_str.as_ptr()) };
    println!("C 字符串长度: {} 个字符", len);

    // 分配和使用 malloc/free（请勿在生产环境如此随意！）
    unsafe {
        let size: size_t = 64;
        let ptr = libc::malloc(size);
        if ptr.is_null() {
            println!("malloc 失败了！内存分配失败（罕见的系统资源耗尽）");
        } else {
            println!("malloc 成功！地址: {:?}", ptr);
            libc::free(ptr); // 记得释放内存，这是 C 的规矩
            println!("free 完毕，C 的内存管理责任感油然而生");
        }
    }
}

1
2
3
4
5
6

你好，Unix 系统调用！
当前进程 PID: 12345
真实用户 ID (UID): 1000
C 字符串长度: 15 个字符
malloc 成功！地址: 0x55a8b2c3e2a0
free 完毕，C 的内存管理责任感油然而生

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

use std::fs::File;
use std::io::{self, Read, Write};

fn main() -> io::Result<()> {
    // 创建一个文件用于写入（如果已存在则截断）
    let mut file = File::create("hello_rust.txt")?;
    
    // 写入数据
    file.write_all(b"你好，Rust 文件系统！\n")?;
    file.write_all(b"这是第二行文字。\n")?;
    
    // 关闭文件（自动在 Drop 时发生）
    drop(file);
    
    // 打开同一个文件用于读取
    let mut file = File::open("hello_rust.txt")?;
    
    // 读取全部内容到字符串
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    
    println!("文件内容：\n{}", contents);
    println!("文件大小：{} 字节", contents.len());
    
    Ok(())
}

1
2
3
4

文件内容：
你好，Rust 文件系统！
这是第二行文字。
文件大小：42 字节

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

use std::fs::File;
use std::io::{self, Read};

fn main() -> io::Result<()> {
    // 方案一：File::create —— 创建新文件或截断已有文件
    // "要么是个新文件，要么把旧的清空重来"
    let mut new_file = File::create("brand_new.txt")?;
    new_file.write_all(b"新文件内容，覆盖一切！")?;

    // 方案二：File::open —— 以只读模式打开已有文件
    // "文件必须存在，不存在就报错"
    let mut existing_file = match File::open("brand_new.txt") {
        Ok(f) => f,
        Err(e) => {
            eprintln!("文件不存在或无法打开：{}", e);
            return Err(e);
        }
    };

    let mut contents = String::new();
    existing_file.read_to_string(&mut contents)?;
    println!("通过 open 读取：{}", contents);

    // 方案三：OpenOptions —— 更精细的控制
    use std::fs::OpenOptions;
    let mut append_file = OpenOptions::new()
        .create(true)           // 文件不存在则创建
        .append(true)           // 以追加模式打开
        .write(true)            // 允许写入
        .open("log.txt")?;

    writeln!(append_file, "日志追加：时间戳 {}", 
             std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
                 .unwrap()
                 .as_secs())?;
    
    println!("日志写入成功！");

    Ok(())
}

1
2

通过 open 读取：新文件内容，覆盖一切！
日志写入成功！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

use std::fs::File;
use std::io::{self, Read, Write, Seek, SeekFrom};

fn main() -> io::Result<()> {
    // 创建测试文件
    let mut file = File::create("binary_data.bin")?;

    // write_all 写入完整的字节切片
    let data = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    file.write_all(data)?;
    drop(file);

    // 重新打开文件进行随机读写
    let mut file = File::open("binary_data.bin")?;

    // seek 到特定位置进行读取
    file.seek(SeekFrom::Start(5))?;  // 跳到开头第5字节（'F'）
    let mut buffer = [0u8; 4];
    let n = file.read(&mut buffer)?;  // 读取4字节
    println!("从位置5读取了 {} 字节: {:?}", n, buffer);
    // 输出：从位置5读取了 4 字节: [70, 71, 72, 73]（即 'F','G','H','I'）

    // seek 也可以用 Current（相对当前位置）和 End（相对文件末尾）
    file.seek(SeekFrom::End(-5))?;  // 跳到倒数第5字节
    let mut pos = file.stream_position()?;
    println!("当前位置（倒数第5字节处）: {}", pos);

    // write_at 特定位置写入
    file.seek(SeekFrom::Start(0))?;
    file.write_all(b"aaaaa")?;  // 用 'a' 覆盖前5个字节

    // 再次读取验证
    file.seek(SeekFrom::Start(0))?;
    let mut verify = Vec::new();
    file.read_to_end(&mut verify)?;
    println!("验证修改后的文件前10字节: {:?}", &verify[..10]);

    Ok(())
}

1
2
3

从位置5读取了 4 字节: [70, 71, 72, 73]
当前位置（倒数第5字节处）: 21
验证修改后的文件前10字节: [97, 97, 97, 97, 97, 70, 71, 72, 73, 74]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use std::fs::File;
use std::io::{self, BufRead, BufReader, BufWriter, Write};

fn main() -> io::Result<()> {
    // 使用 BufWriter 减少系统调用次数
    // 写入 10000 行数据，不带缓冲：可能触发 10000 次 write 系统调用
    // 带缓冲：可能只触发几次（取决于操作系统缓冲区策略）
    let mut file = File::create("buffered_output.txt")?;
    let mut writer = BufWriter::new(file);

    for i in 0..10000 {
        writeln!(writer, "这是第 {:05} 行数据", i)?;
    }
    writer.flush()?; // 确保所有数据都刷到磁盘
    println!("BufWriter: 10000 行写入完成！");

    // 使用 BufReader 高效地按行读取
    let file = File::open("buffered_output.txt")?;
    let reader = BufReader::new(file);
    
    let mut line_count = 0;
    for line in reader.lines() {
        let _ = line?; // 逐行读取，无压力
        line_count += 1;
    }
    println!("BufReader: 成功读取 {} 行", line_count);

    // BufReader 的 lines() 返回一个迭代器，每次迭代会消费一行
    // 如果你想"偷看"下一行而不消费它，可以用 peek（但 std 标准库 BufReader
    // 本身没有 peek！真正的 peek 需要用 BufRead trait 的 fill_buf / consume 组合）
    let file = File::open("buffered_output.txt")?;
    let mut reader = BufReader::new(file);
    
    // fill_buf 会返回指向内部缓冲区的引用，不消费数据
    let first_line_bytes = reader.fill_buf()?;
    let first_line = String::from_utf8_lossy(first_line_bytes);
    println!("第一行（fill_buf 查看）: {}", first_line.trim());
    
    // consume 告诉 BufReader 我们"用掉"了多少字节
    // 找出第一行的长度（直到换行符）
    let first_line_len = first_line_bytes.iter().position(|&b| b == b'\n').map(|p| p + 1).unwrap_or(first_line_bytes.len());
    reader.consume(first_line_len);
    
    // 现在读取真正的"下一行"（即第二行）
    let mut second_line = String::new();
    reader.read_line(&mut second_line)?;
    println!("第二行: {}", second_line.trim());

    Ok(())
}

1
2
3
4

BufWriter: 10000 行写入完成！
BufReader: 成功读取 10000 行
第一行（fill_buf 查看）: 这是第 00000 行数据
第二行: 这是第 00001 行数据

1
2
3

# Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

use std::error::Error;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // 异步创建文件
    let mut file = tokio::fs::File::create("async_hello.txt").await?;
    file.write_all(b"这是异步写入的数据！\n").await?;
    
    // 异步读取文件
    let contents = tokio::fs::read_to_string("async_hello.txt").await?;
    println!("异步读取内容：{}", contents);

    // 异步列目录
    let mut entries = tokio::fs::read_dir(".").await?;
    println!("当前目录文件列表：");
    while let Some(entry) = entries.next_entry().await? {
        let name = entry.file_name().to_string_lossy();
        if name.ends_with(".rs") {
            println!("  📄 {}", name);
        }
    }

    // 异步复制文件
    tokio::fs::copy("async_hello.txt", "async_hello_copy.txt").await?;
    println!("文件复制完成！");

    // 异步获取元数据
    let meta = tokio::fs::metadata("async_hello.txt").await?;
    println!("文件大小：{} 字节", meta.len());

    Ok(())
}

1
2
3
4
5
6

异步读取内容：这是异步写入的数据！

当前目录文件列表：
  📄 src\main.rs
文件复制完成！
文件大小：28 字节

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // 创建临时文件
    let mut file = tokio::fs::File::create("async_trait_demo.txt").await?;
    
    // AsyncWriteExt 提供了方便的异步写入方法
    file.write_all(b"第一行：异步写入就是这么优雅\n").await?;
    file.write_all(b"第二行：不需要回调地狱\n").await?;
    file.write_all(b"第三行：直接 await，神清气爽\n").await?;
    
    // 必须 shutdown 来确保数据 flush
    file.shutdown().await?;
    println!("写入完成并关闭！");

    // 重新打开用于读取
    let mut file = tokio::fs::File::open("async_trait_demo.txt").await?;
    
    // AsyncReadExt 提供了 read_to_end, read_to_string 等方法
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer).await?;
    
    let text = String::from_utf8(buffer)?;
    println!("完整内容：\n{}", text);

    // 按字节读取
    let mut file = tokio::fs::File::open("async_trait_demo.txt").await?;
    let mut buf = [0u8; 16];
    let n = file.read(&mut buf).await?;
    println!("前 {} 字节（原始）: {:?}", n, &buf[..n]);

    Ok(())
}

1
2
3
4
5
6
7
8

写入完成并关闭！
完整内容：
第一行：异步写入就是这么优雅
第二行：不需要回调地狱
第三行：直接 await，神清气爽

前 16 字节（原始）: [229, 173, 151, 230, 152, 141, 232, 168, 128, 58, 229, 165, 189, 245, 203, 191]
// 这是 UTF-8 编码的中文字符"第一行："

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use libc::{c_int, epoll_event, EPOLLIN, EPOLLOUT};
use std::error::Error;

#[repr(transparent)]
struct EpollInstance(c_int);

impl EpollInstance {
    // 创建 epoll 实例
    fn new() -> Result<Self, std::io::Error> {
        unsafe {
            let fd = libc::epoll_create1(0);
            if fd < 0 {
                Err(std::io::Error::last_os_error())
            } else {
                Ok(EpollInstance(fd))
            }
        }
    }

    // 添加文件描述符到 epoll 实例
    fn add_fd(&self, fd: c_int, events: u32) -> Result<(), std::io::Error> {
        unsafe {
            let mut ev = epoll_event {
                events,
                u64: fd as u64,
            };
            let ret = libc::epoll_ctl(
                self.0, 
                libc::EPOLL_CTL_ADD, 
                fd, 
                &mut ev
            );
            if ret < 0 {
                Err(std::io::Error::last_os_error())
            } else {
                Ok(())
            }
        }
    }

    // 等待事件（最多 timeout_ms 毫秒）
    fn wait(&self, events: &mut [epoll_event], timeout_ms: i32) 
        -> Result<usize, std::io::Error> 
    {
        unsafe {
            let n = libc::epoll_wait(
                self.0,
                events.as_mut_ptr(),
                events.len() as c_int,
                timeout_ms
            );
            if n < 0 {
                Err(std::io::Error::last_os_error())
            } else {
                Ok(n as usize)
            }
        }
    }
}

impl Drop for EpollInstance {
    fn drop(&mut self) {
        unsafe { libc::close(self.0); }
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Linux epoll 示例 ===");
    
    let epoll = EpollInstance::new()?;
    println!("epoll 实例创建成功！fd = {}", epoll.0);

    // 创建一个测试用的 pipe（管道）
    let mut fds = [0i32, 0i32];
    unsafe {
        libc::pipe(fds.as_mut_ptr());
    }
    println!("创建 pipe：fd[0]={}, fd[1]={}", fds[0], fds[1]);

    // 注册读事件（EPOLLIN = 准备好读取）
    epoll.add_fd(fds[0], EPOLLIN as u32)?;
    println!("已注册监听 pipe 的读端");

    // 在另一个线程写入数据，触发事件
    std::thread::spawn(move || {
        std::thread::sleep(std::time::Duration::from_millis(100));
        unsafe {
            libc::write(fds[1], b"Hello epoll!" as *const u8 as *const libc::c_void, 12);
        }
        println!("[发送线程] 数据已写入 pipe");
    });

    // 等待事件
    let mut events = [epoll_event { events: 0, u64: 0 }; 10];
    println!("等待 epoll 事件...");
    let n = epoll.wait(&mut events, 3000)?; // 3秒超时
    println!("收到 {} 个事件！", n);
    
    for i in 0..n {
        let fd = events[i].u64 as c_int;
        let event_bits = events[i].events;
        println!("  事件 #{}: fd={}, events=0x{:x}", i, fd, event_bits);
    }

    // 清理
    unsafe {
        libc::close(fds[0]);
        libc::close(fds[1]);
    }

    println!("epoll 示例演示完毕！");
    Ok(())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

=== Linux epoll 示例 ===
epoll 实例创建成功！fd = 3
创建 pipe：fd[0]=4, fd[1]=5
已注册监听 pipe 的读端
等待 epoll 事件...
[发送线程] 数据已写入 pipe
收到 1 个事件！
  事件 #0: fd=4, events=0x1
// 0x1 = EPOLLIN，表示 fd=4 可读
epoll 示例演示完毕！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use libc::{c_int, kevent, kqueue, EVFILT_READ, EV_ADD};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== macOS/BSD kqueue 示例 ===");

    // 创建 kqueue 实例
    let kq = unsafe { kqueue() };
    if kq < 0 {
        return Err("kqueue 创建失败".into());
    }
    println!("kqueue 实例创建成功！fd = {}", kq);

    // 创建一对 Unix socket（类似 pipe，但支持更多事件类型）
    let mut fds = [0i32, 0i32];
    unsafe {
        libc::socketpair(
            libc::AF_UNIX, 
            libc::SOCK_STREAM, 
            0, 
            fds.as_mut_ptr()
        );
    }
    println!("创建 socketpair：fd[0]={}, fd[1]={}", fds[0], fds[1]);

    // 注册读事件
    let change = kevent {
        ident: fds[0] as usize,   // 监视的 fd
        filter: EVFILT_READ as i32, // 读事件过滤器
        flags: EV_ADD,              // 添加事件
        fflags: 0,
        data: 0,
        udata: std::ptr::null_mut(),
    };

    let mut changes = [change];
    let mut events = [kevent {
        ident: 0, filter: 0, flags: 0, fflags: 0, data: 0, udata: std::ptr::null_mut()
    }; 10];

    let n = unsafe {
        libc::kevent(
            kq, 
            changes.as_ptr(), 
            1, 
            events.as_mut_ptr(), 
            events.len() as c_int, 
            std::ptr::null() // 无超时，等待直到有事件
        )
    };

    println!("kevent 返回：{} 个事件", n);

    // 清理
    unsafe {
        libc::close(fds[0]);
        libc::close(fds[1]);
        libc::close(kq);
    }

    Ok(())
}

1
2
3
4

=== macOS/BSD kqueue 示例 ===
kqueue 实例创建成功！fd = 3
创建 socketpair：fd[0]=4, fd[1]=5
kevent 返回：1 个事件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Windows IOCP 概念说明 ===");
    
    println!("
IOCP（I/O Completion Ports）是 Windows 的高性能 I/O 模型。

与 epoll/kqueue 的'就绪通知'模式不同，IOCP 采用'完成通知'模式：

  1. 应用程序发起异步 I/O 操作
  2. 操作系统执行 I/O，同时应用程序可以做其他事
  3. I/O 完成后，结果被放入完成端口的队列
  4. 应用程序从队列中取出结果进行处理

【关键优势】
  - 可以绑定线程池到 IOCP，实现高效的线程利用率
  - 特别适合处理大量并发 I/O 操作
  - 与 Overlapped I/O 深度集成

【Rust 中的使用】
  在 Rust 中，IOCP 主要通过 windows-rs crate 来操作：

  ```rust
  use windows::Win32::Foundation::HANDLE;
  use windows::Win32::System::IO::CreateIoCompletionPort;
  
  let port = CreateIoCompletionPort(
      file_handle,     // 要关联的文件句柄
      existing_port,   // 已有的 IOCP 句柄，None 表示新建
      completion_key,  // 应用自定义的完成键
      num_threads,     // 并发线程数，0 表示自动
  )?;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use mio::event::Event;
use mio::net::{TcpListener, TcpStream};
use mio::{Events, Interest, Poll, Token};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== mio 跨平台 I/O 示例 ===");

    // 创建 Poll 实例——这是 mio 的核心
    // Poll 抽象了 epoll/kqueue/IOCP
    let mut poll = Poll::new()?;
    println!("mio Poll 创建成功！");

    // 创建 Token 用于标识每个注册的事件源
    const SERVER: Token = Token(0);
    const CLIENT: Token = Token(1);

    // 创建一个 TCP 服务器监听
    let addr = "127.0.0.1:0".parse().unwrap();
    let mut server = TcpListener::bind(addr)?;
    let actual_addr = server.local_addr()?;
    println!("服务器绑定到：{}", actual_addr);

    // 将 server 注册到 poll，监听可读事件（ incoming connection）
    poll.registry().register(&mut server, SERVER, Interest::READABLE)?;
    println!("TcpListener 已注册到 poll");

    // 创建一个客户端连接到服务器
    let mut client = TcpStream::connect(actual_addr)?;
    println!("客户端连接中...");

    // 将 client 注册到 poll，监听可写事件（连接建立）
    poll.registry().register(&mut client, CLIENT, Interest::WRITABLE)?;
    println!("TcpStream 已注册到 poll");

    // 事件循环
    let mut events = Events::with_capacity(1024);
    let mut connected = false;

    println!("开始事件循环...");
    for i in 0..10 {
        // 等待事件，100ms 超时
        poll.poll(&mut events, Some(std::time::Duration::from_millis(100)))?;
        
        for event in &events {
            match event.token() {
                SERVER => {
                    println!("[轮次 {}] 服务器端可读！", i);
                    // 接受连接
                    if let Ok((_conn, _addr)) = server.accept() {
                        println!("  -> 接受了新连接！");
                    }
                }
                CLIENT => {
                    println!("[轮次 {}] 客户端可写！", i);
                    if !connected {
                        connected = true;
                        println!("  -> 连接已建立！");
                    }
                }
                _ => {}
            }
        }
        
        if i == 0 && connected {
            println!("仅演示第一轮事件即可，退出循环");
            break;
        }
    }

    println!("mio 示例完成！");
    Ok(())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

=== mio 跨平台 I/O 示例 ===
mio Poll 创建成功！
服务器绑定到：127.0.0.1:51867
客户端连接中...
TcpListener 已注册到 poll
TcpStream 已注册到 poll
开始事件循环...
[轮次 0] 客户端可写！
  -> 连接已建立！
[轮次 0] 服务器端可读！
  -> 接受了新连接！
mio 示例完成！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use mio::{Poll, Token, Interest, event::Source};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== mio Evented 注册机制详解 ===");

    // mio 使用 Token 来标识每个被注册的对象
    // Token 是你自己定义的，通常用枚举或 newtype
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    struct MyToken(usize);

    let poll = Poll::new()?;
    let registry = poll.registry();

    // Registry 提供的核心方法：
    // 1. register - 注册一个事件源
    // 2. reregister - 重新注册（修改监听的事件）
    // 3. deregister - 取消注册

    println!("mio Registry 核心操作：");
    println!("  - registry.register(source, token, interests)");
    println!("  - registry.reregister(source, token, interests)");
    println!("  - registry.deregister(source)");
    println!();
    println!("Interest 组合：");
    println!("  - Interest::READABLE  : 监听可读事件");
    println!("  - Interest::WRITABLE  : 监听可写事件");
    println!("  - Interest::READABLE | Interest::WRITABLE : 两者都监听");
    println!();

    // mio 0.8 支持 Interest::AIO 和 Interest::LINUX_AIO
    // 但在大多数平台上，它们退化为 READABLE
    println!("mio 底层自动选择最优的后端：");
    println!("  - Linux 2.6+    -> epoll");
    println!("  - macOS / BSD   -> kqueue");
    println!("  - Windows       -> IOCP (通过 IOCP_overlapped)");
    println!();

    // Token 的使用示例
    println!("Token 示例（模拟多连接场景）：");
    #[derive(Debug)]
    enum ConnectionToken {
        Http(u32),   // HTTP 连接，id = u32
        Ftp,         // FTP 连接
        Stdin,       // 标准输入
    }

    println!("  ConnectionToken::Http(42)  -> 标识 ID=42 的 HTTP 连接");
    println!("  ConnectionToken::Ftp        -> 标识 FTP 连接");
    println!("  ConnectionToken::Stdin     -> 标识标准输入");

    println!();
    println!("mio 的设计哲学：");
    println!("  '让最底层的 I/O 多路复用对上层代码透明'");
    println!("  你只需要写一次代码，就能在所有主流平台上高效运行。");

    Ok(())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::net::{TcpListener, TcpStream, UdpSocket};
use std::io::{Read, Write};
use std::error::Error;
use std::thread;
use std::time::Duration;

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== TCP/UDP 套接字基础 ===\n");

    // ============ TCP 示例 ============
    println!("【TCP 示例】");

    // 创建监听套接字，OS 会自动分配一个可用端口
    let listener = TcpListener::bind("127.0.0.1:0")?;
    let server_addr = listener.local_addr()?;
    println!("  [服务器] 绑定到：{}", server_addr);

    // 启动服务器处理线程
    let server_handle = thread::spawn(move || {
        match listener.accept() {
            Ok((mut stream, client_addr)) => {
                println!("  [服务器] 收到来自 {} 的连接！", client_addr);

                // 读取客户端数据
                let mut buf = [0u8; 1024];
                let n = stream.read(&mut buf).unwrap();
                let msg = String::from_utf8_lossy(&buf[..n]);
                println!("  [服务器] 收到消息：{}", msg.trim());

                // 回复客户端
                stream.write_all(b"Hello from server!").unwrap();
                println!("  [服务器] 已回复");
            }
            Err(e) => eprintln!("  [服务器] 接受连接失败：{}", e),
        }
    });

    // 客户端连接
    thread::sleep(Duration::from_millis(50)); // 等待服务器线程启动
    let mut client_stream = TcpStream::connect(server_addr)?;
    println!("  [客户端] 已连接到 {}", server_addr);

    // 发送数据
    client_stream.write_all(b"Hello from client!")?;
    println!("  [客户端] 消息已发送");

    // 读取回复
    let mut buf = [0u8; 1024];
    let n = client_stream.read(&mut buf).unwrap();
    let reply = String::from_utf8_lossy(&buf[..n]);
    println!("  [客户端] 收到回复：{}", reply);

    server_handle.join().unwrap();

    // ============ UDP 示例 ============
    println!("\n【UDP 示例】");

    let udp_server = UdpSocket::bind("127.0.0.1:0")?;
    let udp_addr = udp_server.local_addr()?;
    println!("  [UDP 服务器] 绑定到：{}", udp_addr);

    let udp_server_addr = udp_addr;

    let receiver = thread::spawn(move || {
        let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
        socket.connect(udp_server_addr).unwrap();

        let mut buf = [0u8; 1024];
        println!("  [UDP 接收端] 等待数据...");
        // 注意：connect 后的 UDP socket 应该用 recv() 而非 recv_from()
        // 因为 connect 把 socket 绑定到了特定的远端地址
        let n = socket.recv(&mut buf).unwrap();
        let msg = String::from_utf8_lossy(&buf[..n]);
        println!("  [UDP 接收端] 收到：{}", msg);
    });

    let sender = thread::spawn(move || {
        let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
        thread::sleep(Duration::from_millis(50));
        socket.send_to(b"UDP message via send_to!", udp_server_addr).unwrap();
        println!("  [UDP 发送端] 数据已发送");
    });

    sender.join().unwrap();
    receiver.join().unwrap();

    println!("\nTCP/UDP 基础演示完成！");
    Ok(())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

=== TCP/UDP 套接字基础 ===

【TCP 示例】
  [服务器] 绑定到：127.0.0.1:51868
  [客户端] 已连接到 127.0.0.1:51868
  [客户端] 消息已发送
  [服务器] 收到来自 127.0.0.1:51870 的连接！
  [服务器] 收到消息：Hello from client!
  [服务器] 已回复
  [客户端] 收到回复：Hello from server!

【UDP 示例】
  [UDP 发送端] 数据已发送
  [UDP 接收端] 收到：UDP message via send_to!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

use std::net::{TcpListener, TcpStream};
use std::io::{Read, Write};
use std::error::Error;
use std::thread;

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== TCP 三次握手与 connect/accept ===\n");

    // TCP 服务器四部曲
    println!("【TCP 服务器生命周期】");
    println!("  1. socket()  - 创建套接字（Rust 隐藏了这步）");
    println!("  2. bind()    - 绑定地址和端口");
    println!("  3. listen()  - 开始监听连接请求");
    println!("  4. accept() - 接受客户端连接，返回新的连接套接字");
    println!();

    // TCP 客户端两部曲
    println!("【TCP 客户端生命周期】");
    println!("  1. socket()  - 创建套接字");
    println!("  2. connect() - 连接到服务器（触发三次握手）");
    println!();

    // 实际演示
    let listener = TcpListener::bind("127.0.0.1:0")?;
    let addr = listener.local_addr()?;
    println!("服务器监听：{}", addr);

    // 设置非阻塞，接受测试
    listener.set_nonblocking(true)?;

    let handle = thread::spawn(move || {
        // 模拟忙碌的服务器，同时处理多个连接
        let (mut stream, _) = listener.accept().unwrap();
        let mut buf = [0u8; 64];
        if let Ok(n) = stream.read(&mut buf) {
            println!("收到数据：{:?}", String::from_utf8_lossy(&buf[..n]));
        }
        stream.write_all(b"PONG").unwrap();
    });

    // 客户端连接
    let mut stream = TcpStream::connect(addr)?;
    stream.write_all(b"PING")?;
    
    let mut buf = [0u8; 64];
    let n = stream.read(&mut buf)?;
    println!("收到响应：{:?}", String::from_utf8_lossy(&buf[..n]));

    handle.join().unwrap();

    println!("\nTCP 连接建立过程演示完毕！");
    Ok(())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

=== TCP 三次握手与 connect/accept ===

【TCP 服务器生命周期】
  1. socket()  - 创建套接字（Rust 隐藏了这步）
  2. bind()    - 绑定地址和端口
  3. listen()  - 开始监听连接请求
  4. accept() - 接受客户端连接，返回新的连接套接字

【TCP 客户端生命周期】
  1. socket()  - 创建套接字
  2. connect() - 连接到服务器（触发三次握手）

服务器监听：127.0.0.1:51871
收到数据："PING"
收到响应："PONG"

1
2
3

# Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Tokio 异步网络 ===\n");

    // 创建一个 echo 服务器
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
    let addr = listener.local_addr()?;
    println!("异步 echo 服务器监听：{}", addr);

    // 服务器任务（只处理单个连接后即退出，方便演示）
    let server = async {
        // 异步接受一个连接
        let (mut socket, client_addr) = listener.accept().await.unwrap();
        println!("[服务器] 收到连接：{}", client_addr);

        let mut buf = vec![0u8; 1024];
        loop {
            match socket.read(&mut buf).await {
                Ok(0) => {
                    println!("[服务器] 客户端 {} 断开连接", client_addr);
                    return;
                }
                Ok(n) => {
                    if socket.write_all(&buf[..n]).await.is_err() {
                        return;
                    }
                }
                Err(_) => return,
            }
        }
    };

    // 客户端连接
    let client = async {
        // 等待服务器启动
        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
        
        let mut stream = tokio::net::TcpStream::connect(addr).await.unwrap();
        println!("[客户端] 已连接到服务器");

        // 发送数据
        let msgs = vec!["Hello", "Async", "World", "!"];
        for msg in &msgs {
            stream.write_all(msg.as_bytes()).await.unwrap();
            print!("[客户端] 发送：{}\n", msg);
        }
        stream.shutdown().await.unwrap();

        // 读取响应
        let mut buf = vec![0u8; 1024];
        let n = stream.read(&mut buf).await.unwrap();
        let response = String::from_utf8_lossy(&buf[..n]);
        println!("[客户端] 收到响应：{}", response);
    };

    // 并发运行服务器和客户端
    tokio::join!(server, client);

    Ok(())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

=== Tokio 异步网络 ===

[客户端] 已连接到服务器
[服务器] 收到连接：127.0.0.1:51872
[客户端] 发送：Hello
[客户端] 发送：Async
[客户端] 发送：World
[客户端] 发送：！
[客户端] 收到响应：HelloAsyncWorld！
[服务器] 客户端 127.0.0.1:51872 断开连接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use std::error::Error;
use std::os::unix::net::{UnixStream, UnixListener};
use std::io::{Read, Write};
use std::thread;
use std::time::Duration;
use std::fs;

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Unix Domain Socket ===\n");

    let socket_path = "/tmp/rust_uds_demo.sock";

    // 清理可能存在的旧 socket 文件
    let _ = fs::remove_file(socket_path);

    // 创建 UDS 监听器（类似 TCP 的 TcpListener）
    let listener = UnixListener::bind(socket_path)?;
    println!("[服务器] UDS 监听：{}", socket_path);

    // 服务器接受连接
    let server = thread::spawn(move || {
        match listener.accept() {
            Ok((mut stream, _)) => {
                println!("[服务器] 收到连接！");
                
                let mut buf = [0u8; 128];
                let n = stream.read(&mut buf).unwrap();
                let msg = String::from_utf8_lossy(&buf[..n]);
                println!("[服务器] 收到消息：{}", msg.trim());
                
                stream.write_all(b"UDS echo: OK!").unwrap();
                println!("[服务器] 已回复");
            }
            Err(e) => eprintln!("[服务器] 接受失败：{}", e),
        }
    });

    thread::sleep(Duration::from_millis(30));

    // 客户端连接
    let mut client = UnixStream::connect(socket_path)?;
    println!("[客户端] 已连接到 UDS");

    client.write_all(b"Hello from UDS client!")?;
    println!("[客户端] 消息已发送");

    let mut buf = [0u8; 128];
    let n = client.read(&mut buf).unwrap();
    let reply = String::from_utf8_lossy(&buf[..n]);
    println!("[客户端] 收到回复：{}", reply);

    server.join().unwrap();

    // 清理 socket 文件
    let _ = fs::remove_file(socket_path);
    println!("\nUDS 演示完成！");

    Ok(())
}

1
2
3
4
5
6
7
8
9

=== Unix Domain Socket ===

[服务器] UDS 监听：/tmp/rust_uds_demo.sock
[客户端] 已连接到 UDS
[客户端] 消息已发送
[服务器] 收到连接！
[服务器] 收到消息：Hello from UDS client!
[服务器] 已回复
[客户端] 收到回复：UDS echo: OK!

1
2
3

# Cargo.toml
[dependencies]
socket2 = "0.5"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use socket2::{Socket, Domain, Type, Protocol};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== socket2 高级配置 ===\n");

    // 创建原始 socket（类似 C 的 socket() 系统调用）
    // Domain: AF_INET (IPv4) 或 AF_INET6 (IPv6) 或 AF_UNIX (Unix Domain)
    // Type: SOCK_STREAM (TCP) 或 SOCK_DGRAM (UDP)
    // Protocol: 0 表示由系统自动选择
    let sock = Socket::new(Domain::IPV4, Type::STREAM, Protocol::TCP)?;
    println!("原始 socket 创建成功！");

    // 设置 SO_REUSEADDR（允许地址重用）
    // 这在服务器快速重启时非常重要，否则会报 "Address already in use"
    sock.set_reuse_address(true)?;
    println!("已设置 SO_REUSEADDR");

    // 设置 SO_REUSEPORT（允许端口重用，Linux 3.9+）
    #[cfg(target_os = "linux")]
    {
        sock.set_reuse_port(true)?;
        println!("已设置 SO_REUSEPORT（Linux 特有）");
    }

    // 设置 socket 发送/接收缓冲区大小
    let send_buf_size = sock.send_buffer_size()?;
    let recv_buf_size = sock.recv_buffer_size()?;
    println!("默认发送缓冲区：{} 字节", send_buf_size);
    println!("默认接收缓冲区：{} 字节", recv_buf_size);

    // 增大缓冲区（提高高吞吐场景的性能）
    sock.set_send_buffer_size(1024 * 1024)?;  // 1MB
    sock.set_recv_buffer_size(1024 * 1024)?;
    println!("已增大缓冲区到 1MB");

    // 设置 TCP_NODELAY（禁用 Nagle 算法，降低延迟）
    sock.set_nodelay(true)?;
    println!("已设置 TCP_NODELAY（禁用 Nagle 算法）");

    // 设置 SO_KEEPALIVE（检测对方是否崩溃）
    sock.set_keepalive(true)?;
    println!("已启用 SO_KEEPALIVE");

    // 获取 socket 的文件描述符
    let fd = sock.as_raw_fd();
    println!("底层文件描述符：{}", fd);

    // 绑定到地址
    let addr: std::net::SocketAddr = "127.0.0.1:0".parse()?;
    sock.bind(&addr.into())?;
    println!("已绑定到：{}", sock.local_addr()?);

    // 开始监听
    sock.listen(128)?;
    println!("进入监听模式！");

    // 关闭 socket
    drop(sock);
    println!("Socket 已关闭");

    println!("\nsocket2 演示完成！");
    println!("socket2 的核心价值：");
    println!("  - 完整的 socket 选项控制");
    println!("  - 支持多种协议族（IPV4/IPV6/UNIX）");
    println!("  - 精细调优网络性能参数");

    Ok(())
}