Differenze

Queste sono le differenze tra la revisione selezionata e la versione attuale della pagina.

--- programmazione:rust:appunti_sparsi [08/05/2026 13:53] – Fabio Di Matteo
+++ programmazione:rust:appunti_sparsi [30/05/2026 15:51] (versione attuale) – [Funzioni async con tokio] Fabio Di Matteo
@@ Linea 248: / Linea 248: @@
   * [[programmazione:rust:gtk4_windows|Gtk-rs su windows]]
+  * [[programmazione:rust:gtkrs:gestione_memoria|Appunti sulla gestione della memoria in Gtkrs e Rust]]
+  * [[https://www.freemedialab.org/code/project.php?p=video_cutter|Progetto Gtkrs completo di esempio ]]
 ===== I thread =====
@@ Linea 285: / Linea 287: @@
 La condivisione è sicura. Potremmo anche condividere **mpsc::channel** per usare nei vari thread il contenuto magari di un canale str o altro.
+===== Funzioni async con tokio =====
+Eseguire funzioni che richiedono tempo con il runtime tokio:
+<code rust>
+use tokio::time::{Duration, sleep};
+async fn asincrona() {
+    sleep(Duration::from_millis(3000)).await;
+    println!("Ciao dalla asincrona!");
+}
+#[tokio::main]
+async fn main() {
+    // Avvio una funzione async con tokio e passo il controllo
+    // alle istruzioni successive
+    tokio::spawn(async { asincrona().await });
+    println!("Scrivo dal main");
+    sleep(Duration::from_millis(5000)).await;
+}
+</code>
+Aspettiamo che una funzione,lanciata da tokio precedentemente, finisca del lavoro "lento" per poi continuare il flusso del programma principale.
+<code rust>
+use tokio::time::{Duration, sleep};
+async fn asincrona() -> i32 {
+    sleep(Duration::from_millis(6000)).await;
+    println!("Ciao dalla asincrona!");
+    return 6000;
+}
+#[tokio::main]
+async fn main() {
+    // Avvio una funzione async con tokio e passo il controllo
+    // alle istruzioni successive.
+    let r = tokio::spawn(async { asincrona().await });
+    // Scrivo qualcosa dal main e dopo un secondo il programma dovrebbe terminare
+    // Invece no! Aspetto il valore di "r" proveniente dalla funzione async con
+    // r.await
+    println!("Scrivo dal main");
+    sleep(Duration::from_millis(1000)).await;
+    // Ora che il valore di "r" è disponibile lo stampo se tutto è andato bene,
+    // oppure stampo "0"
+    println!(
+        "Ho aspettato il valore di r {}",
+        r.await.unwrap_or_else(|_| 0)
+    );
+}
+</code>
+===== Comunicare con le funzioni async =====
+<code rust>
+use std::sync::mpsc;
+use tokio::time::{Duration, sleep};
+async fn asincrona(t: mpsc::Sender<&str>) {
+    loop {
+        t.send("Ciao dalla fn async!").unwrap();
+        sleep(Duration::from_millis(2000)).await;
+    }
+}
+#[tokio::main]
+async fn main() {
+    let (tx, rx) = mpsc::channel::<&str>();
+    let tx_clone = tx.clone();
+    tokio::spawn(async { asincrona(tx_clone).await });
+    // Un loop che riceve messaggi dalla funzione asincrona e
+    // li stampa a video.
+    loop {
+        sleep(Duration::from_millis(500)).await;
+        let val = rx.recv().unwrap_or_else(|_| "Niente.");
+        println!("Ricevo: {}", val)
+    }
+}
+</code>
@@ Linea 385: / Linea 473: @@
 fn main() {
+    // Utilizzarla senza controllo errori così:
+    // let myexe_path = exe_dir();
+    // println!(
+    //     "Il percorso del mio eseguibile: {}",
+    //     myexe_path.unwrap().display().to_string()
+    // );
     let myexe_path = exe_dir();
-    println!(
+    match myexe_path {
-        "Il percorso del mio eseguibile: {}",
+        Ok(p) => {
-        myexe_path.unwrap().display().to_string()
+            println!(
-    );
+                "Il percorso del mio eseguibile è {}",
+                p.display().to_string()
+            );
+        }
+        Err(e) => {
+            eprintln!("Problemi nel ricavare il percorso:{} ", e)
+        }
+    }
 }
 </code>