以下是基于您提供的内容整理的完整示例代码，包含TCP服务器、TCP客户端和UDP通信的完整实现：

完整TCP服务器示例

use compio_net::{TcpListener, TcpStream};
use futures_util::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 绑定到本地地址8080端口
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("Server listening on 127.0.0.1:8080");
    
    loop {
        // 接受新连接
        let (mut stream, addr) = listener.accept().await?;
        println!("Accepted connection from: {}", addr);
        
        // 为每个连接创建新任务
        tokio::spawn(async move {
            let mut buf = vec![0; 1024];
            
            // 读取客户端数据
            match stream.read(&mut buf).await {
                Ok(n) if n == 0 => return,  // 连接关闭
                Ok(n) => {
                    let received = String::from_utf8_lossy(&buf[..n]);
                    println!("Received {} bytes: {}", n, received);
                    
                    // 回写相同数据
                    if let Err(e) = stream.write_all(&buf[..n]).await {
                        eprintln!("Write error: {}", e);
                    }
                }
                Err(e) => eprintln!("Read error: {}", e),
            }
        });
    }
}

完整TCP客户端示例

use compio_net::TcpStream;
use futures_util::{AsyncReadExt, AsyncWriteExt};
use std::time::Duration;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 连接到服务器
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    println!("Connected to server at 127.0.0.1:8080");
    
    // 要发送的消息
    let messages = [
        "Hello", 
        "This is compio-net", 
        "Testing TCP connection",
        "Goodbye"
    ];
    
    for msg in messages {
        // 发送数据
        println!("Sending: {}", msg);
        stream.write_all(msg.as_bytes()).await?;
        
        // 接收响应
        let mut buf = vec![0; 1024];
        let n = stream.read(&mut buf).await?;
        let response = String::from_utf8_lossy(&buf[..n]);
        println!("Received: {}", response);
        
        // 等待1秒
        tokio::time::sleep(Duration::from_secs(1)).await;
    }
    
    Ok(())
}

完整UDP通信示例

UDP服务器端

use compio_net::UdpSocket;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 绑定到本地端口8081
    let socket = UdpSocket::bind("127.0.0.1:8081").await?;
    println!("UDP server listening on 127.0.0.1:8081");
    
    let mut buf = vec![0; 1024];
    
    loop {
        // 接收数据
        let (n, addr) = socket.recv_from(&mut buf).await?;
        let received = String::from_utf8_lossy(&buf[..n]);
        println!("Received {} bytes from {}: {}", n, addr, received);
        
        // 发送响应
        let response = format!("Echo: {}", received);
        socket.send_to(response.as_bytes(), addr).await?;
    }
}

UDP客户端端

use compio_net::UdpSocket;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 创建UDP socket并绑定到随机端口
    let socket = UdpSocket::bind("127.0.0.1:0").await?;
    println!("Local address: {}", socket.local_addr()?);
    
    // 连接到服务器
    let server_addr = "127.0.0.1:8081";
    socket.connect(server_addr).await?;
    println!("Connected to server at {}", server_addr);
    
    // 要发送的消息
    let messages = [
        "Hello UDP", 
        "This is a test", 
        "From compio-net",
        "Goodbye UDP"
    ];
    
    for msg in messages {
        // 发送数据
        println!("Sending: {}", msg);
        socket.send(msg.as_bytes()).await?;
        
        // 接收响应
        let mut buf = vec![0; 1024];
        let n = socket.recv(&mut buf).await?;
        let response = String::from_utf8_lossy(&buf[..n]);
        println!("Received: {}", response);
    }
    
    Ok(())
}

零拷贝操作完整示例

use compio_net::TcpStream;
use compio::buf::{BufResult, IntoInner};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 连接到服务器
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    
    // 准备要发送的数据
    let send_data = vec![1, 2, 3, 4, 5];
    println!("Sending data: {:?}", send_data);
    
    // 使用零拷贝发送
    let BufResult(res, buf) = stream.send_all(send_data).await;
    res?;
    
    // 取回缓冲区(如果需要重用)
    let original_buf = buf.into_inner();
    println!("Original buffer after send: {:?}", original_buf);
    
    // 准备接收缓冲区
    let mut recv_buf = Vec::with_capacity(1024);
    
    // 使用零拷贝接收精确5字节
    let BufResult(res, buf) = stream.recv_exact(recv_buf).await;
    let n = res?;
    
    // 取回填充了数据的缓冲区
    let filled_buf = buf.into_inner();
    println!("Received {} bytes: {:?}", n, &filled_buf[..n]);
    
    Ok(())
}

多连接处理完整示例

use compio_net::{TcpListener, TcpStream};
use futures_util::{AsyncReadExt, AsyncWriteExt};
use std::sync::Arc;

async fn handle_connection(mut stream: TcpStream) -> std::io::Result<()> {
    let mut buf = vec![0; 1024];
    
    loop {
        // 读取数据
        let n = match stream.read(&mut buf).await {
            Ok(n) if n == 0 => return Ok(()),  // 连接关闭
            Ok(n) => n,
            Err(e) => {
                eprintln!("Read error: {}", e);
                return Err(e);
            }
        };
        
        // 处理数据
        let received = String::from_utf8_lossy(&buf[..n]);
        println!("Received: {}", received);
        
        // 回写数据
        if let Err(e) = stream.write_all(&buf[..n]).await {
            eprintln!("Write error: {}", e);
            return Err(e);
        }
    }
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 绑定到本地地址
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    let listener = Arc::new(listener);
    println!("Server started on 127.0.0.1:8080");
    
    // 根据CPU核心数创建工作线程
    let num_workers = num_cpus::get();
    println!("Starting {} worker threads", num_workers);
    
    for _ in 0..num_workers {
        let listener = listener.clone();
        
        tokio::spawn(async move {
            loop {
                // 接受新连接
                match listener.accept().await {
                    Ok((stream, addr)) => {
                        println!("Accepted connection from {}", addr);
                        
                        // 处理连接
                        if let Err(e) = handle_connection(stream).await {
                            eprintln!("Connection error: {}", e);
                        }
                    }
                    Err(e) => eprintln!("Accept error: {}", e),
                }
            }
        });
    }
    
    // 等待Ctrl+C信号
    tokio::signal::ctrl_c().await?;
    println!("Shutting down server...");
    
    Ok(())
}

这些完整示例展示了compio-net库的主要功能，包括TCP/UDP通信、零拷贝操作和多连接处理。您可以根据实际需求调整缓冲区大小、并发工作线程数等参数以获得最佳性能。