0Pricing
Learn Rust Coding · Lección

Construcción de aplicaciones asíncronas con Tokio

Utilice el runtime Tokio para ejecutar tareas asíncronas de forma eficiente y gestionar operaciones de E/S y otras operaciones concurrentes.

Construcción de aplicaciones asíncronas con Tokio es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 3 lecciones en total.

Conozca el runtime Tokio

¡Bienvenido de nuevo! En la lección anterior aprendió sobre async y await. Pero ¿cómo se ejecuta realmente una función async?

Ahí es donde entra en juego un runtime asíncrono como Tokio. Tokio es una potente biblioteca que proporciona el entorno de ejecución para su código asíncrono de Rust.

  • Programa y ejecuta Futures.
  • Gestiona operaciones de E/S no bloqueantes.
  • Administra tareas concurrentes de forma eficiente.

Ejecución de su código asíncrono

Para comenzar a usar Tokio, normalmente se utiliza la macro de atributo #[tokio::main]. Esta macro transforma su async fn main() en un fn main() estándar que inicializa el runtime de Tokio y ejecuta su código asíncrono.

Considérela el punto de entrada de su aplicación asíncrona.

use tokio;

#[tokio::main]
async fn main() {
  println!("Hello from Tokio!");
}

Creación de nuevas tareas asíncronas

Una de las características principales de Tokio es la posibilidad de ejecutar varias operaciones asíncronas de forma concurrente. Puede lograrlo mediante tokio::spawn.

tokio::spawn recibe un Future y programa su ejecución en el runtime de Tokio. Esto permite que la tarea principal continúe ejecutándose mientras la tarea creada se ejecuta en segundo plano.

  • No bloquea.
  • Devuelve un JoinHandle para esperar a que termine.
  • Las tareas se ejecutan de forma independiente.

<code>tokio::spawn</code> en acción

Veamos cómo tokio::spawn permite ejecutar código de forma concurrente. Observe que aparecen ambos mensajes, pero el mensaje «done» podría imprimirse antes que «task complete» debido a la espera.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  // Spawn a new task
  let handle = tokio::spawn(async {
    sleep(Duration::from_secs(1)).await;
    println!("Async task complete!");
  });

  println!("Main task continuing...");

  // Wait for the spawned task to finish
  handle.await.unwrap();
  println!("All tasks done.");
}

Espera de varias tareas

Cuando tiene varias tareas, a menudo necesita esperar a que todas terminen. Tokio proporciona la macro tokio::join! para este propósito.

tokio::join! permite esperar de forma concurrente varios futures y combinar sus resultados. Es similar a aplicar `await` a varios JoinHandle, pero suele ser más conciso para conjuntos fijos de futures.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  let task1 = async {
    sleep(Duration::from_secs(1)).await;
    println!("Task 1 finished");
    1
  };

  let task2 = async {
    sleep(Duration::from_millis(500)).await;
    println!("Task 2 finished");
    2
  };

  let (result1, result2) = tokio::join!(task1, task2);
  println!("Results: {}, {}", result1, result2);
}

E/S asíncrona de archivos con Tokio

Las operaciones tradicionales con archivos pueden bloquear el hilo, lo que resulta perjudicial para las aplicaciones asíncronas. El módulo tokio::fs de Tokio proporciona versiones asíncronas de las operaciones del sistema de archivos.

Esto permite que su aplicación siga respondiendo incluso al leer archivos grandes o realizar muchas operaciones con archivos, ya que la E/S se gestiona de forma no bloqueante.

  • tokio::fs::read_to_string
  • tokio::fs::write
  • tokio::fs::File para un mayor control

Lectura asíncrona de un archivo

Así puede leer un archivo de forma asíncrona mediante tokio::fs::read_to_string. Para que este código se ejecute, asegúrese de tener un archivo llamado hello.txt en el mismo directorio que su proyecto de Rust (por ejemplo, dentro de src/ o en la raíz del proyecto) con algún contenido.

use tokio::fs;

#[tokio::main]
async fn main() {
  let path = "hello.txt";
  // Create a dummy file for the example if it doesn't exist
  // In a real app, you'd handle file creation/existence more robustly
  if let Err(_) = fs::metadata(path).await {
    fs::write(path, "Hello, Tokio file!").await.unwrap();
  }

  match fs::read_to_string(path).await {
    Ok(content) => println!("File content: '{}'", content),
    Err(e) => eprintln!("Error reading file: {}", e),
  }
}

Operaciones de red asíncronas

Tokio destaca especialmente en la programación de redes. Su módulo tokio::net ofrece primitivas no bloqueantes para la comunicación TCP y UDP.

Esto es fundamental para crear servidores o clientes de alto rendimiento capaces de gestionar muchas conexiones simultáneamente sin necesitar un hilo independiente para cada una.

  • tokio::net::TcpListener para servidores.
  • tokio::net::TcpStream para conexiones de clientes.

Estructura básica de un servidor TCP asíncrono

Aunque un servidor completo es complejo, este fragmento muestra el bucle principal de un servidor TCP asíncrono que utiliza Tokio. Escucha las conexiones entrantes e imprime un mensaje por cada una. Intente ejecutarlo y, después, abra el navegador en http://127.0.0.1:8080 para ver las conexiones.

use tokio::net::TcpListener;

#[tokio::main]
async fn main() {
  let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
  println!("Listening on: {}", listener.local_addr().unwrap());

  loop {
    let (socket, addr) = listener.accept().await.unwrap();
    println!("Accepted connection from: {}", addr);
    // In a real server, you'd spawn a task to handle the socket
    // tokio::spawn(async move { handle_connection(socket).await; });
  }
}

// fn handle_connection(socket: TcpStream) { /* ... */ } // Placeholder

Desafío de tareas de Tokio

Considere el siguiente código de Rust que utiliza Tokio. ¿Cuál será el *primer* mensaje que se imprimirá en la consola cuando se ejecute este programa?

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  tokio::spawn(async {
    sleep(Duration::from_millis(200)).await;
    println!("Task 1: Done");
  });

  tokio::spawn(async {
    sleep(Duration::from_millis(100)).await;
    println!("Task 2: Done");
  });

  println!("Main: Starting tasks...");

  sleep(Duration::from_millis(300)).await;
  println!("Main: Finishing.");
}

Repaso: creación con Tokio

¡Ha dado un paso importante en la creación de aplicaciones asíncronas con Rust y Tokio!

  • Tokio actúa como el runtime asíncrono que ejecuta su código async.
  • #[tokio::main] es el punto de entrada asíncrono de su programa.
  • tokio::spawn permite ejecutar varias tareas de forma concurrente.
  • tokio::join! ayuda a esperar varios futures.
  • Tokio proporciona E/S no bloqueante para archivos (tokio::fs) y redes (tokio::net).

Estas herramientas son fundamentales para crear aplicaciones de Rust altamente concurrentes y con buena capacidad de respuesta. ¡Siga practicando!

Preguntas frecuentes

¿La lección «Construcción de aplicaciones asíncronas con Tokio» es gratis?

Sí — el texto completo de «Construcción de aplicaciones asíncronas con Tokio» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 3 lecciones en total.

¿Qué aprenderé en «Construcción de aplicaciones asíncronas con Tokio»?

Utilice el runtime Tokio para ejecutar tareas asíncronas de forma eficiente y gestionar operaciones de E/S y otras operaciones concurrentes. Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.

¿Cuánto tiempo toma la lección «Construcción de aplicaciones asíncronas con Tokio»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Introducción a Async/Await
  2. Construcción de aplicaciones asíncronas con Tokio
  3. Trabajo con Futures y tareas
← Volver a Learn Rust Coding