rust实践-异步并发socket通信

客户端

rust 复制代码
[package]
name = "rust_client"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1.14.0", features = ["full"] }
rust 复制代码
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:7878").await?;
    let (mut rd, mut wr) = stream.split();

    let mut buf = vec![0; 1024];
    loop {
        let n = match rd.read(&mut buf).await {
            Ok(n) if n == 0 => {
				println!("read zero data, finish");
				return Ok(());
			}
            Ok(n) => {
				let msg = String::from_utf8_lossy(&buf[..n]).to_string();
				println!("read {} bytes'data : {}", n, msg);
				n
			}
            Err(e) => {
                println!("failed to read from socket; err = {}", e);
                return Err(e);
            }
        };
        match wr.write_all(&buf[0..n]).await {
            Ok(_) => {
				println!("write data to server success");
				()
			}
            Err(e) => {
                println!("failed to write to socket; err = {}", e);
                return Err(e);
            }
        }
        wr.flush().await?;
    }
}

服务端

rust 复制代码
[package]
name = "rust_server"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1.14.0", features = ["full"] }
rust 复制代码
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:7878").await?;

    loop {
        let (mut stream, _) = listener.accept().await?;
		tokio::spawn(async move {
            let (mut rd, mut wr) = stream.split();
			println!("read and write socket spilt success");
			let data = "Hello, world!\n";
			wr.write_all(data.as_bytes()).await;
			println!("write data success");

    		let mut buf = vec![0; 1024];
    		match rd.read(&mut buf).await {
        		Ok(n) => {
            		let msg = String::from_utf8_lossy(&buf[..n]);
            		println!("read data : {}", msg);
        		},
        		Err(e) => eprintln!("Failed to read from socket; err = {}", e),
   			}
        });
	}
}

附录

from_utf8_lossy

String::from_utf8_lossy() 函数将字节数组转换为字符串

接受一个字节数组作为参数,并尝试将其转换为 UTF-8 编码的字符串

如果字节数组包含无效的 UTF-8 字符,则这些字符将被替换为问号 ?

from_utf8_lossy() 函数返回一个 Cow 类型的对象

这个对象实现了 ToString trait

所以可以使用 to_string() 方法将其转换为 String 类型的字符串

如果字节数组的长度很大,这个函数还可以使用 &str 类型来节省内存

Cow

Cow 是一个"借用或拥有(borrow or own)"字符串类型

其中的 Cow 是"借用或拥有(borrow or own)"的缩写。

它的定义如下:

rust 复制代码
pub enum Cow<'a, B>
where
    B: 'a + ToOwned + ?Sized,
{
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}

在 Rust 中,字符串通常采用 String 或 &str 两种类型。

String 类型是一个可变的字符串类型,实际内容被存储在堆上,并且拥有内存所有权。

&str 类型是一个不可变的字符串切片类型,它的实际内容被存储在其他地方,比如堆上或者栈上,并且不拥有内存所有权。

Cow 类型可以用于同时支持 String 和 &str 两种类型。它的第一个泛型参数 'a 用于指定借用的生命周期,可以是任意标识符,表示 'a 参数对类型的所有权没有影响。第二个泛型参数 B 是一个类型参数,用于指定实际的数据类型。

在 Cow 中,Borrowed(&'a B) 表示借用另一个类型 B 的内容,而 Owned(::Owned) 表示拥有 B 类型的所有权。
如果 B 类型已经拥有内存所有权,则返回 Owned 类型,否则返回 Borrowed 类型。
这使得 Cow 类型在不需要分配内存的情况下,可以支持可变类型和不可变类型的字符串。

相关推荐
如夏倾城19 小时前
VRRP(虚拟路由器冗余协议Virtual Router Redundancy Protocol)
网络·python·网络协议·安全·智能路由器·负载均衡·信息与通信
SomeOtherTime1 天前
第 11 讲(大结局):编译期元编程与零拷贝架构——卫生声明宏(macro_rules!)、过程宏 AST 手术刀与 Serde 零反射序列化的终极合龙
rust
张小姐的猫1 天前
【基于 WebSocket 的多用户网页五子棋】—— 认识第三方库Websocketpp
网络·websocket·网络协议
LightBreeze20021 天前
IS-IS 基本概念详解——报文类型、地址结构与网络拓扑
网络·lsp·路由协议·net·is-is
SomeOtherTime1 天前
番外篇(第 12 讲):走向工业界深水区——从物理定律看 Rust 在真实工程中的“降维打击”与“阿喀琉斯之踵”
开发语言·rust
Kapaseker1 天前
Rust 桌面开发到底怎么选?先看这篇文章!
rust
奶油话梅糖1 天前
容器启停 2.5 毫秒:11 天 1,700 Star 的 Kiri,用一个 900 KB 的 PID 1 干掉了 runc 和 dockerd
前端·人工智能·rust
小乖写代码2 天前
提交注册验证 · WhatsApp /v2/register
android·网络·账号注册
多弗朗皮卡丘2 天前
网络基础:数据链路层与其他协议或技术
linux·网络·tcp/ip
wflynn2 天前
GitHub 今日推荐|kiri:clone3 系统调用直达容器,2.5 毫秒启动无 runc 中间层
docker·rust·kubernetes·开源·github·containers