【小沐学Rust】Rust实现TCP网络通信

于 2024-08-25 22:11:37 发布
阅读量1k 收藏 30
点赞数 10
分类专栏： Web 围炉夜话 文章标签： rust 开发语言 后端 tcp udp socket 网络通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhy321/article/details/140855162
版权

文章目录

1、简介

Rust 语言是一种高效、可靠的通用高级语言。其高效不仅限于开发效率，它的执行效率也是令人称赞的，是一种少有的兼顾开发效率和执行效率的语言。
Rust 语言由 Mozilla 开发，最早发布于 2014 年 9 月。
在这里插入图片描述

  • Rust的用途
    开发人员可在网络软件（如 Web 服务器、邮件服务器和 Web 浏览器）领域使用 Rust。 Rust 的身影还会出现在编译器和解释器、虚拟化和软件容器、数据库、操作系统和加密中。 你还可以利用 Rust 编译适用于嵌入式设备的游戏、命令行程序、Web 程序集程序和应用程序。

  • Rust的内存机制
    Rust 是现有系统软件语言（如 C 和 C++）的一种安全替代语言。 与 C 和 C++ 一样，Rust 没有大型运行时或垃圾回收器，这几乎与所有其他现代语言形成了鲜明对比。 但是，与 C 和 C++ 不同的是，Rust 保证了内存安全。 Rust 可以避免很多与在 C 和 C++ 中遇到的内存使用错误相关的 bug。

  • Rust的特点

    • 类型安全：编译器可确保不会将任何操作应用于错误类型的变量。
    • 内存安全：Rust 指针（称为“引用”）始终引用有效的内存。
    • 无数据争用：Rust 的 borrow 检查器通过确保程序的多个部分不能同时更改同一值来保证线程安全。
    • 零成本抽象：Rust 允许使用高级别概念，例如迭代、接口和函数编程，将性能成本控制在最低，甚至不会产生成本。 这些抽象的性能与手工编写的底层代码一样出色。
    • 最小运行时：Rust 具有极小的可选运行时。 为了有效地管理内存，此语言也不具有垃圾回收器。 在这一点上，Rust 非常类似于 C 和 C++ 之类的语言。
    • 面向裸机：Rust 可以用于嵌入式和“裸机”编程，因此适合用于编写操作系统内核或设备驱动程序。

  • Rust的编译器
    虽然可以直接使用 Rust 编译器 (rustc) 来生成箱，但大多数项目都使用 Rust 生成工具和名为 Cargo 的依赖项管理器。
    Cargo 可以为你做许多事情，包括：

    • 使用 cargo new 命令创建新的项目模板。
    • 使用 cargo build 编译项目。
    • 使用 cargo run 命令编译并运行项目。
    • 使用 cargo test 命令测试项目。
    • 使用 cargo check 命令检查项目类型。
    • 使用 cargo doc 命令编译项目的文档。
    • 使用 cargo publish 命令将库发布到 crates.io。
    • 通过将箱的名称添加到 Cargo.toml 文件来将依赖箱添加到项目。

  • Rust的在线开发环境：
    操场是 Rust 开发的 IDE，可在 https://play.rust-lang.org/ Internet 上访问。 任何人都可以访问操场。 你可以编写代码，然后在相同的环境中编译和运行代码。 以下屏幕截图显示了操场环境。 在工具栏的最右侧，“CONFIG”菜单的选项可以设置环境的首选项。

https://play.rust-lang.org/

浏览器运行如下：
在这里插入图片描述

2、安装

2.1 安装Rust

https://www.rust-lang.org/zh-CN/tools/install

在Windows上要使用 Rust，请下载安装器，然后运行该程序并遵循屏幕上的指示。当看到相应提示时，您可能需要安装 Microsoft C++ 生成工具。如果您不在 Windows 上，参看 “其他安装方式”。
在这里插入图片描述
下载rustup-init.exe，鼠标直接双击运行之。
（1）选择安装方式
在这里插入图片描述
（2）rust下载中
在这里插入图片描述
（3）rust安装完成
在这里插入图片描述
（4）查看rust版本号

rustc -V
# rustc --version

在这里插入图片描述

cargo --version

在这里插入图片描述

2.2 VsCode安装Rust插件

（1）rust-analyzer：它会实时编译和分析你的 Rust 代码，提示代码中的错误，并对类型进行标注。你也可以使用官方的 rust 插件取代。
rust-analyzer是官方维护的rls（rust语言服务器）2.0版本，已有VSCode插件。

Rust：这是官方开发的；
rust-analyzer：这是社区开发的；

在这里插入图片描述
（2）rust syntax：为代码提供语法高亮。
在这里插入图片描述
（3）Dependi：帮助你分析当前项目的依赖是否是最新的版本。
在这里插入图片描述
（4）Even Better TOML：Rust 使用 toml 做项目的配置管理。
在这里插入图片描述

（5）Tabnine：基于 AI 的自动补全，可以帮助你更快地撰写代码。
在这里插入图片描述

3、快速入门

3.1 命令行构建

  • （1）创建一个新目录
    对于 Windows 命令提示符，请运行以下命令：
mkdir hello-yxy
cd hello-yxy

在这里插入图片描述

  • （2）编写你的第一个 Rust 程序

创建一个名为 main.rs 的新文件，并使用编辑器将以下代码写入其中：

fn main() {
	println!("Hello, yxy!");
}

在 Windows 中可以运行以下命令：

rustc main.rs
.\main.exe

在这里插入图片描述

3.2 Cargo构建

-（3）使用 Cargo 创建项目
让我们使用 Cargo 编写并运行相同的程序。
并运行以下命令：

cargo new hello-cargo-yxy

命令如下：
在这里插入图片描述
此命令生成名为 hello-cargo 的新目录（其中包含 src 子目录），并自动添加两个文件：

hello-cargo/
     Cargo.toml
     src/
         main.rs

在这里插入图片描述
Cargo.toml 是 Rust 的清单文件。 这个文件可用于保存项目及依赖项的元数据。
Src 子目录中的 main.rs 文件可用于编写应用程序代码。

-（4）使用 Cargo 生成并运行你的程序
使用 cargo run 命令：

cd hello-cargo-yxy
cargo run

在这里插入图片描述

3.3 Cargo添加依赖

  • 新建项目

Cargo 创建一个新项目：

cargo new hello-rust

这会生成一个名为 hello-rust 的新目录，其中包含以下文件：

hello-rust
|- Cargo.toml
|- src
  |- main.rs

Cargo.toml 为 Rust 的清单文件。其中包含了项目的元数据和依赖库。
src/main.rs 为编写应用代码的地方。

  • 代码编译
cargo run
  • 添加依赖
    为应用添加依赖。您可以在 crates.io，即 Rust 包的仓库中找到所有类别的库。在 Rust 中，我们通常把包称作“crates”。

Ferris-Says是一个Rust编程语言编写的库，它以Rust的标志性吉祥物Ferris为特色，帮助你在命令行中打印出带有Ferris元素的文本。不仅如此，该项目还提供了一个名为fsays的二进制工具，使用户可以方便地从标准输入或文件读取文本，并以独特的ASCII艺术风格呈现。

在 Cargo.toml 文件中添加以下信息（从 crate 页面上获取）：

[dependencies]
ferris-says = "0.3.1"

Cargo 就会安装该依赖。

cargo build

在这里插入图片描述
运行此命令会创建一个新文件 Cargo.lock，该文件记录了本地所用依赖库的精确版本。

打开 main.rs，添加示意代码：

use ferris_says::say; // from the previous step
use std::io::{stdout, BufWriter};

fn main() {
    let stdout = stdout();
    let message = String::from("Hello fellow Rustaceans!");
    let width = message.chars().count();

    let mut writer = BufWriter::new(stdout.lock());
    say(&message, width, &mut writer).unwrap();
}

运行代码：

cargo run

在这里插入图片描述

4、基本语法

4.1 main 的函数

每个 Rust 程序都必须有一个名为 main 的函数。 main 函数中的代码始终是 Rust 程序中运行的第一个代码。 我们可以从 main 函数内部或从其他函数内部调用其他函数。

fn main() {
    println!("Hello, world!");
}

4.2 代码缩进

在函数体中，大多数代码语句以分号 ; 结尾。
起始代码语句从左边距缩进四个空格。

4.3 todo! 宏

Rust 中的宏类似于采用可变数量的输入参数的函数。 todo! 宏用于标识 Rust 程序中未完成的代码。

fn main() {
    // Display the message "Hello, world!"
    todo!("Display the message by using the println!() macro");
}

在这里插入图片描述

4.4 println! 宏

println! 宏需要一个或多个输入参数，这些参数会显示在屏幕或标准输出中。

fn main() {
    // Our main function does one task: show a message
    // println! displays the input "Hello, world!" to the screen
    println!("Hello, world!");
}

在这里插入图片描述

  • {} 参数的值替换
    println! 宏将文本字符串中的每个大括号 {} 实例替换为列表中下一个参数的值。
fn main() {
    // Call println! with three arguments: a string, a value, a value
    println!("The first letter of the English alphabet is {} and the last letter is {}.", 'A', 'Z');
}

在这里插入图片描述

4.5 变量的使用

在 Rust 中，变量用关键字 let 声明。
每个变量都有一个唯一的名称。
在 Rust 中，变量绑定默认不可变。

// Declare a variable
// let a_number;
let a_number = 10;
 
// Declare a second variable and bind the value
let a_word = "Ten";
    
// Bind a value to the first variable
a_number = 10;

println!("The number is {}.", a_number);
println!("The word is {}.", a_word);

若要更改值，必须先使用 mut 关键字将变量绑定设为可变。

// The `mut` keyword lets the variable be changed
let mut a_number = 10; 
println!("The number is {}.", a_number);

// Change the value of an immutable variable
a_number = 15;
println!("Now the number is {}.", a_number);

将 number 变量创建为 32 位整数。

let number: u32 = 14;
println!("The number is {}.", number);

Rust 附带一些用于表达数字、文本和真实信息的内置基元数据类型。
内置数据类型:

整数数字
浮点数
布尔型
字符
  • （1）数字：整数和浮点值。
let number_64 = 4.0;      // compiler infers the value to use the default type f64
let number_32: f32 = 5.0; // type f32 specified via annotation
  • （2）布尔值：True 或 false
// Declare variable to store result of "greater than" test, Is 1 > 4? -- false
let is_bigger = 1 > 4;
println!("Is 1 > 4? {}", is_bigger);
  • （3）文本：字符和字符串

字符：

let uppercase_s = 'S';
let lowercase_f = 'f';
let smiley_face = '😃';

字符串：

// Specify the data type "char"
let character_1: char = 'S';
let character_2: char = 'f';
   
// Compiler interprets a single item in quotations as the "char" data type
let smiley_face = '😃';

// Compiler interprets a series of items in quotations as a "str" data type and creates a "&str" reference
let string_1 = "miley ";

// Specify the data type "str" with the reference syntax "&str"
let string_2: &str = "ace";

println!("{} is a {}{}{}{}.", smiley_face, character_1, string_1, character_2, string_2);

4.6 元组

元组是集中到一个复合值中的不同类型值的分组。 元组中的各个值称为元素。 这些值指定为括在括号中的逗号分隔列表 (, , …)。

// Declare a tuple of three elements
let tuple_e = ('E', 5i32, true);

// Use tuple indexing and show the values of the elements in the tuple
println!("Is '{}' the {}th letter of the alphabet? {}", tuple_e.0, tuple_e.1, tuple_e.2);

4.7 结构

结构是多个其他类型的组合体。 结构中的元素称为字段。 与元组一样，结构中的字段可以具有不同的数据类型。 结构类型的一个显著好处是，可以命名每个字段，以便清楚展示相应值的含义。

// Classic struct with named fields
struct Student { name: String, level: u8, remote: bool }

// Tuple struct with data types only
struct Grades(char, char, char, char, f32);

// Unit struct
struct Unit;

实例化结构:

// Instantiate classic struct, specify fields in random order, or in specified order
let user_1 = Student { name: String::from("Constance Sharma"), remote: true, level: 2 };
let user_2 = Student { name: String::from("Dyson Tan"), level: 5, remote: false };

// Instantiate tuple structs, pass values in same order as types defined
let mark_1 = Grades('A', 'A', 'B', 'A', 3.75);
let mark_2 = Grades('B', 'A', 'A', 'C', 3.25);

println!("{}, level {}. Remote: {}. Grades: {}, {}, {}, {}. Average: {}", 
         user_1.name, user_1.level, user_1.remote, mark_1.0, mark_1.1, mark_1.2, mark_1.3, mark_1.4);
println!("{}, level {}. Remote: {}. Grades: {}, {}, {}, {}. Average: {}", 
         user_2.name, user_2.level, user_2.remote, mark_2.0, mark_2.1, mark_2.2, mark_2.3, mark_2.4);

4.8 枚举

与结构一样，枚举变体可以具有命名字段，但也可以具有没有名称的字段或根本没有字段。 与结构类型一样，枚举类型也采用大写形式。

enum WebEvent {
    // An enum variant can be like a unit struct without fields or data types
    WELoad,
    // An enum variant can be like a tuple struct with data types but no named fields
    WEKeys(String, char),
    // An enum variant can be like a classic struct with named fields and their data types
    WEClick { x: i64, y: i64 }
}

4.9 函数

  • （1）定义函数
    Rust 中的函数定义以 fn 关键字开头。
fn main() {
    println!("Hello, world!");
    goodbye();
}

fn goodbye() {
    println!("Goodbye.");
}

在这里插入图片描述

  • （2）传递输入参数
    如果函数具有输入参数，请命名每个参数并在函数声明的开头指定数据类型。
fn goodbye(message: &str) {
    println!("\n{}", message);
}

fn main() {
    let formal = "Formal: Goodbye.";
    let casual = "Casual: See you later!";
    goodbye(formal);
    goodbye(casual);
}

在这里插入图片描述

  • （3）返回值

当函数返回某个值时，请在函数参数列表后面和函数体的左大括号前面添加语法 -> 。

fn divide_by_5(num: u32) -> u32 {
    num / 5
}

fn main() {
    let num = 25;
    println!("{} divided by 5 = {}", num, divide_by_5(num));
}

在这里插入图片描述

5、TCP通信

5.1 测试一

5.1.1 TCP服务端

use std::net::TcpListener;

fn main() {
    // 监听地址: 127.0.0.1:9090
    let listener = TcpListener::bind("127.0.0.1:9090").unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        println!("Connection established!");
    }
}

在这里插入图片描述

5.1.2 TCP客户端

fn main() {
    use std::net::TcpStream;

    if let Ok(stream) = TcpStream::connect("127.0.0.1:9090") {
        println!("Connected to the server!");
    } else {
        println!("Couldn't connect to server...");
    }
}

在这里插入图片描述

5.2 测试二

5.2.1 TCP服务端

//
//@dev server用于监听
//
use std::net::{TcpListener, TcpStream}; 
use std::thread;
//std::thread库的引入，对输入的每一个流创建一个线程
use std::time;
use std::io::{self, Read, Write};
//引入io库，为了处理错误

fn handle_client(mut stream: TcpStream) -> io::Result<()> {
    //该函数用来处理client（就是这个流），流的格式或者说他的类型就是TcpStream
    let mut buf = [0; 512];
    //创建一个叫buf的数组，内容为0，长度为512
    loop {
        //该循环表示server端永久提供服务，因为默认服务器为永不关闭的
        let bytes_read = stream.read(&mut buf)?;
        //从流里面读内容，读到buf中
        if bytes_read == 0 {
            return Ok(());
            //如果读到的为空（即0），则说明已经结束了
        }
        stream.write(&buf[..bytes_read])?;
        //否则把它写回去
        thread::sleep(time::Duration::from_secs(1));
        //调用sleep函数实现服务的间隔，间隔1s
        let s = String::from_utf8(buf.to_vec());
        println!("receive data from client: {:?}", &s);
    }
}

fn main() -> io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080")?;
    //定义一个listener，bind函数里面填写的是监听的的ip与端口号,?是一种简写，等价于except,unwrap
    let mut thread_vec: Vec<thread::JoinHandle<()>> = Vec::new();
    //创建一个容器，用来放线程的句柄
    for stream in listener.incoming() {
        println!("new client is connected.");
        let stream = stream.expect("failed");
        //转换一下stream流，出现问题，提示“失败”，没有问题，继续下面的操作
        let handle = thread::spawn(move || {
            handle_client(stream).unwrap_or_else(|error| eprintln!("{:?}", error));
        });
        //对输入的每一个流来创建一个线程，利用必包进行一个处理
        thread_vec.push(handle);
        //把handle加到容器里面
    }

    for handle in thread_vec {
        //此循环为了等待线程的结束
        handle.join().unwrap();
        //等待结束的具体实现
    }
    Ok(())
}

在这里插入图片描述

5.2.2 TCP客户端

//
//@dev server端进行监听，在client端发起链接
//
use std::io::{self, prelude::*, BufReader, Write};
use std::net::TcpStream;
use std::str;

fn main() -> io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8080")?;
    //创建变量stream，直接连接sever端
    for _ in 0..10 {
        println!("please input:");
        let mut input = String::new();
        //定义一个String类型的输入
        io::stdin().read_line(&mut input).expect("Failed to read!");
        //从标准输入读入一行，读入input里面，如果有问题的话，提示“读取失败”
        stream.write(input.as_bytes()).expect("Failed to write!");
        //把input读取的内容，转换成bytes后，写到stream流里面去，如果写入失败，提示“写入失败”

        let mut reader = BufReader::new(&stream);
        //从stream流创建一个读，目的是要从我们的server端读，
        let mut buffer: Vec<u8> = Vec::new();
        //用Vector创建一个buffer变量 
        reader.read_until(b'\n', &mut buffer).expect("Failed to read into buffer");
        //一直读到换行为止（b'\n'中的b表示字节），读到buffer里面
        println!("read from server: {}", str::from_utf8(&buffer).unwrap());
        //把读取到buffer中的内容打印出来
        println!("");
        //再来一个换行，美化输出
    }
    Ok(())
}

在这里插入图片描述

结语

如果您觉得该方法或代码有一点点用处，可以给作者点个赞，或打赏杯咖啡；╮(￣▽￣)╭
如果您感觉方法或代码不咋地//(ㄒoㄒ)//，就在评论处留言，作者继续改进；o_O???
如果您需要相关功能的代码定制化开发，可以留言私信作者；(✿◡‿◡)
感谢各位大佬童鞋们的支持！( ´ ▽´ )ﾉ ( ´ ▽´)っ！！！

爱看书的小沐
关注
专栏目录
rust实现socket通信
weixin_35756624的博客
01-08 1250
好的，我来给您介绍一下如何使用 Rust 语言进行 socket 通信。 首先，您需要在 Cargo.toml 文件中添加以下依赖： [dependencies] tokio = { version = "0.2", features = ["full"] } 然后，您可以在 Rust 代码中使用以下代码来创建一个 socket 连接： use tokio::net::TcpStream; #...
rust实现一个tcp server
by186的博客
05-24 1409
服务端 use std ::net::{TcpListener,TcpStream}; use std::thread; use std::time; use std::io; use std::io::{Read,Write}; fn handle_client(mut stream: TcpStream) -> io::Result<()>{ let mut buf = [0;512]; for _ in 0..1000{ let bytes_
Rust Web（一）—— 自建TCP Server
AlanKSorata的博客
07-24 1473
前段时间小小学习了一下Rust的基础内容，出于学习Web开发的需求，也为巩固学过的Rust基础，就尝试记录一下自己学习RustWeb的点滴；实现环境OSIDEPyCharm本文为个人的学习随记，关于Rust的基础部分没有提及太多，难免出现某些细节上的疏漏，还请读者慎重参考；......
rust简单tcpserver和tcpcline
weixin_44305700的博客
06-11 485
rust 简单tcp server
在 Rust 中实现 TCP : 3. TCP连接四元组
xuejianxinokok的专栏
03-05 1220
到目前为止，已经确保接收到正确的 IPv4 数据包，并且已经实现了一种机制，将传入数据包与其各自的状态相关联，并由唯一的连接四元组作为键。从最初的握手到数据传输和最终的断开，连接的状态都会被仔细跟踪，以保证可靠和有序的数据交换。脚本来启动程序，该脚本将构建并执行二进制文件并为其提供必要的提升网络访问权限，接下来，将使用 Netcat 尝试与应用程序建立 TCP 连接，最后为了可视化，将使用 tshark 通过运行 tshark -I tun0 来监视和捕获 tun0 接口上的数据包。这是我们下一个目标。
Rust标准库-实现一个TCP服务、Rust使用套接字
西京刀客
07-25 3457
Rust标准库 net模块 提供用于TCP / UDP通信的网络原语。 该模块为传输控制和用户数据报协议以及 IP 和套接字地址的类型提供网络功能。
Rust实现TCP通信
最新发布
05-31
Rust网络编程可以通过多种方式实现，附件展示如何使用Rust标准库中的std::net模块来创建一个基本的TCP服务器和客户端。 在这个示例中，服务器 ** 本地的7878端口，并接受来自客户端的连接。一旦接受到连接，服务器就...
TCP / UDP / Unix通信的异步网络原语-Rust开发
05-27
TCP / UDP / Unix通信的异步网络原语。 async-net用于TCP / UDP / Unix通信的异步网络原语。 这个箱子是std :: net和std :: os :: unix :: net的异步版本。 实现此板条箱使用async-io进行异步I / O，并阻止DNS查找。...
rust网络编程中文及源码
04-20
《Rust网络编程中文版及源码》是一个深入探讨Rust语言在网络编程领域的资源集合，包含详细的中文教程和源代码示例。Rust语言以其内存安全、并发性能和系统级编程能力著称，是构建高性能网络应用的理想选择。本资料...
如何学习Rust语言.docx
04-16
- **TCP服务器**：通过实现一个简单的TCP服务器，学习网络编程和异步I/O处理。 - **Web框架**：创建一个小型的Web框架，深入了解HTTP协议及其处理流程。 - **游戏开发**：利用Rust的高性能特性，开发一个简单的游戏...
rust-tcp-async-client:rust tokio 异步多客户网络框架
04-13
rust-tcp-async-client rust实现的异步多客户端网络框架，基于和,可自定义通讯协议 插件化采用lua。应用场景im,game server,bot等.golang 实现的网络框架就很多了,个人希望能在rust做一些微不足道的贡献,该项目的代码也很简陋属于 demo ,线上生产还是需要深加工.欢迎:clapping_hands:各位大佬吐槽毕竟我还是rust萌新项目更多的代码 Copy 自 hhhhhh :balloon:框架:balloon: 主线程维护多个client,将消息分发至lua。 :balloon:性能:balloon: 性能和并发这我不想说,我等萌新再弱鸡,Rust的优势会弥补我们的不足。弘扬Rust势在必行emm......Golang弟弟表示不服.... :balloon:协议:balloon: 自定义协议部分并没有抽离出来，因为本人正处于并将长期处于萌新阶段。。hhhh 请阅读源码codec.rs来实现自己的协议即可 编码器采用的 tokio的Codec :balloon:插件:balloon: 在P
于Tokio和RabbitMQ进行Rust进程间通信的实现
AI天才研究院
07-28 1615
在实际项目开发中，多进程之间的通信是一个非常重要的环节。如何实现跨进程的异步消息队列通信呢？基于Tokio和RabbitMQ进行Rust进程间通信的实现是什么样子的呢？本文将详细探讨其中的原理、流程及使用方法，并给出完整的代码实例，让读者直观感受到这种通信方式的便捷性和稳定性。当客户端需要与RabbitMQ进行通信时，首先创建一个RabbitMQ的代理。然后，客户端就可以通过这个代理与RabbitMQ进行交互。Tokio提供了诸如TCP、UDP之类的网络通信相关的功能。RabbitMQ采用AMQP协议。
001 Rust 网络编程，实现 TCP 服务端和客户端程序
令狐一冲
04-25 5583
本例子用Rust实现一个基于TCP的echo的服务端和客户端的程序，用Rust演示简单的网络程序。 服务端 服务端实现类似于我们之前写过的http服务端的实现。涉及到的知识点主要是std::io和std::net。 代码如下： use std::io::{Error, Read, Write}; use std::net::{TcpListener, TcpStream}; use std::th...
Rust网络编程入门：TCP与UDP的精髓解析
silenceallat的博客
04-18 953
本文深入探讨了Rust语言中的网络编程基础，详细介绍了TCP和UDP协议的使用方法。通过实际案例，我们学习了如何使用Rust标准库进行TCP和UDP编程，并探讨了如何使用async-std库和tokio进行异步网络编程。同时，我们还介绍了网络编程中的性能优化和错误处理技巧。希望本文能为初学者提供Rust网络编程的敲门砖，并在实际项目中灵活应用所学知识。
Rust tcp 客户端和服务端实现
、Edgar的博客
08-21 4122
客户端 use std::io::{self, Write}; use std::net::TcpStream; fn main() { let mut stream = TcpStream::connect("127.0.0.1:8080").expect("connect failed"); loop { let mut input = String::new(); let size = io::stdin().read_line(&mut input).expect
Rust从入门到暴走（24）--- Rust的并发编程之线程间通信
Luca的博客, 网络安全Hacker，人工智能AIer，区块链Web3er，全栈软件开发er
04-05 338
instead, share memory by communicating.” – 这个思想来源于Go编程语言文档中的口号在 Rust 编程语言中，Channel 是一种线程间通信（Inter-thread Communication）的方式，它允许不同的线程之间进行数据交换。Channel 中有两个重要的角色：发送端（Transmitter）和接收端（Receiver）。发送端负责将数据发送到 Channel 中，而接收端负责从 Channel 中接收数据。
rust实现TCP服务器
nothing
04-01 870
rust实现TCP服务器
Rust UDP简单通讯 TCP通讯
will_csdn_go的博客
09-05 630
在这个例子中，我们首先使用UdpSocket的bind函数来绑定到一个随机的本地端口。每当有新的客户端连接后，就会创建一个新的线程来处理这个客户端的数据请求。对于每个客户端连接，服务器将读取客户端发送的数据，然后回复一个固定的消息。需要注意的是，上面的代码仅仅是演示了 TCP 通信的基本用法，实际上在生产环境中，还需要考虑更多的因素，例如错误处理、异常情况处理、并发性等等。当收到服务器的回复后，客户端会将接收到的数据打印到控制台上。以下是一个简单的例子，说明如何使用Rust的UDP模块来进行UDP通讯。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值