O módulo tokio da linguagem Rust fornece um método de programação assíncrono eficiente, e o módulo de canal é um de seus principais componentes. Este tutorial apresentará o tokio module channel além do mspc::Channel mencionado acima, existem três tipos: oneshot, broadcast e watch.Este artigo analisa seus cenários de uso, características de negócios, vantagens e desvantagens respectivamente.
Canal é um mecanismo de comunicação usado para passar dados entre diferentes threads. Ele permite que diferentes threads passem dados enviando e recebendo mensagens, de modo a realizar a cooperação e a sincronização entre os threads.
Na linguagem Rust, o componente de canal do módulo tokio fornece uma implementação de canal assíncrona, eficiente e de tipo seguro. Ele suporta vários tipos de canais, incluindo oneshot, broadcast e watch.
canal único
Um canal oneshot é um canal que só pode enviar uma mensagem uma vez. Sua característica é que o remetente só pode enviar uma mensagem uma vez e o destinatário só pode receber uma mensagem uma vez. Assim que uma mensagem é enviada ou recebida, o canal é fechado.
O canal Oneshot é adequado para os seguintes cenários:
- Mensagens únicas precisam ser passadas entre threads.
- Um valor de retorno precisa ser passado entre threads.
- Uma notificação de evento precisa ser passada entre threads.
As características comerciais do canal oneshot são as seguintes:
- A mensagem só pode ser enviada uma vez, garantindo a unicidade da mensagem.
- A mensagem só pode ser recebida uma vez, o que garante a integridade da mensagem.
- As operações de envio e recebimento são sem bloqueio, o que pode melhorar o desempenho simultâneo do programa.
As vantagens do canal oneshot incluem:
- Simples e fácil de usar, basta enviar e receber mensagens.
- Seguro e confiável, garantindo a singularidade e integridade da mensagem.
- Desempenho eficiente, as operações de envio e recebimento não bloqueiam.
As desvantagens incluem:
- A mensagem só pode ser enviada uma vez e não é adequada para cenários que exigem a entrega de várias mensagens.
- Não é possível lidar com o caso de vários receptores.
Código de amostra
Veja a seguir um exemplo de código que usa o canal oneshot para passar o valor de retorno:
use tokio::sync::oneshot;
async fn do_something() -> i32 {
// 创建一个oneshot channel
let (tx, rx) = oneshot::channel();
// 在一个异步任务中发送消息
tokio::spawn(async move {
let result = 42;
tx.send(result).unwrap();
});
// 在当前任务中接收消息
let result = rx.await.unwrap();
result
}
#[tokio::main]
async fn main() {
let result = do_something().await;
println!("result = {}", result);
}
复制代码canal de transmissão
Um canal de transmissão é um canal que pode enviar mensagens várias vezes. Sua característica é que pode haver vários destinatários, e cada destinatário pode receber todas as mensagens enviadas pelo remetente.
O canal de transmissão é adequado para os seguintes cenários:
- As mensagens precisam ser passadas várias vezes entre os threads.
- As mensagens precisam ser transmitidas entre threads.
As características comerciais do canal de transmissão são as seguintes:
- As mensagens podem ser enviadas várias vezes, o que é adequado para cenários em que as mensagens precisam ser entregues várias vezes.
- Pode haver vários receptores, o que é adequado para cenários em que as mensagens precisam ser transmitidas.
- As operações de envio e recebimento são sem bloqueio, o que pode melhorar o desempenho simultâneo do programa.
As vantagens dos canais de transmissão incluem:
- As mensagens podem ser enviadas várias vezes, o que é adequado para cenários em que as mensagens precisam ser entregues várias vezes.
- Pode haver vários receptores, o que é adequado para cenários em que as mensagens precisam ser transmitidas.
- Desempenho eficiente, as operações de envio e recebimento não bloqueiam.
As desvantagens incluem:
- A ordem das mensagens não pode ser garantida.
- Lógica de processamento adicional é necessária para lidar com o caso de vários receptores.
Código de amostra
Aqui está um exemplo de código para transmitir uma mensagem usando um canal de transmissão:
use tokio::sync::broadcast;
async fn do_something() {
// 创建一个broadcast channel
let (tx, mut rx) = broadcast::channel(10);
// 在一个异步任务中发送消息
tokio::spawn(async move {
for i in 0..10 {
tx.send(i).unwrap();
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
});
// 在多个异步任务中接收消息
for _ in 0..3 {
let mut rx = rx.clone();
tokio::spawn(async move {
loop {
match rx.recv().await {
Ok(msg) => println!("recv msg = {}", msg),
Err(_) => break,
}
}
});
}
}
#[tokio::main]
async fn main() {
do_something().await;
}
复制代码assistir canal
Um canal de observação é um canal que pode enviar mensagens várias vezes. Sua característica é que pode haver vários destinatários, e cada destinatário pode receber a última mensagem enviada pelo remetente.
O canal de observação é adequado para os seguintes cenários:
- As mensagens precisam ser passadas várias vezes entre os threads.
- Tópicos precisam se inscrever para as últimas notícias.
As características comerciais do canal de exibição são as seguintes:
- As mensagens podem ser enviadas várias vezes, o que é adequado para cenários em que as mensagens precisam ser entregues várias vezes.
- Pode haver vários receptores, o que é adequado para cenários que precisam se inscrever para as últimas notícias.
- As operações de envio e recebimento são sem bloqueio, o que pode melhorar o desempenho simultâneo do programa.
As vantagens dos canais de exibição incluem:
- As mensagens podem ser enviadas várias vezes, o que é adequado para cenários em que as mensagens precisam ser entregues várias vezes.
- Pode haver vários receptores, o que é adequado para cenários que precisam se inscrever para as últimas notícias.
- Desempenho eficiente, as operações de envio e recebimento não bloqueiam.
As desvantagens incluem:
- A ordem das mensagens não pode ser garantida.
- Lógica de processamento adicional é necessária para lidar com o caso de vários receptores.
Código de amostra
Aqui está um exemplo de código para se inscrever nas últimas notícias usando um canal de exibição:
use tokio::sync::watch;
async fn do_something() {
// 创建一个watch channel
let (tx, mut rx) = watch::channel(0);
// 在一个异步任务中发送消息
tokio::spawn(async move {
for i in 0..10 {
tx.send(i).unwrap();
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
});
// 在多个异步任务中接收消息
for _ in 0..3 {
let mut rx = rx.clone();
tokio::spawn(async move {
loop {
let msg = rx.recv().await.unwrap();
println!("recv msg = {}", msg);
}
});
}
}
#[tokio::main]
async fn main() {
do_something().await;
}
复制代码Resumir
O componente de canal do módulo tokio é um mecanismo de comunicação assíncrono eficiente que pode ser usado para colaboração e sincronização entre threads. Os três tipos de canais, oneshot, broadcast e watch, possuem características próprias e são adequados para diferentes cenários. No desenvolvimento real, é necessário selecionar o tipo apropriado de acordo com as necessidades do negócio e usá-lo e processá-lo razoavelmente.