Ferrugem - Simultaneidade

Na programação simultânea, diferentes partes de um programa são executadas independentemente. Por outro lado, na programação paralela, diferentes partes de um programa são executadas ao mesmo tempo. Ambos os modelos são igualmente importantes à medida que mais computadores tiram proveito de seus múltiplos processadores.

Tópicos

Podemos usar threads para executar códigos simultaneamente. Nos sistemas operacionais atuais, o código de um programa executado é executado em um processo e o sistema operacional gerencia vários processos ao mesmo tempo. No seu programa, você também pode ter peças independentes que rodam simultaneamente. Os recursos que executam essas peças independentes são chamados de threads.

Criando um Tópico

o thread::spawnfunção é usada para criar um novo thread. A função spawn leva um encerramento como parâmetro. O encerramento define o código que deve ser executado pelo thread. O exemplo a seguir imprime algum texto de um thread principal e outro texto de um novo thread.

//import the necessary modules
use std::thread;
use std::time::Duration;

fn main() {
   //create a new thread
   thread::spawn(|| {
      for i in 1..10 {
         println!("hi number {} from the spawned thread!", i);
         thread::sleep(Duration::from_millis(1));
      }
   });
   //code executed by the main thread
   for i in 1..5 {
      println!("hi number {} from the main thread!", i);
      thread::sleep(Duration::from_millis(1));
   }
}

Resultado

hi number 1 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the main thread!
hi number 2 from the spawned thread!
hi number 3 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the spawned thread!
hi number 4 from the main thread!

O thread principal imprime valores de 1 a 4.

NOTE- O novo tópico será interrompido quando o tópico principal terminar. A saída deste programa pode ser um pouco diferente a cada vez.

o thread::sleepfunção força um thread a parar sua execução por um curto período, permitindo que um thread diferente seja executado. Os threads provavelmente se revezarão, mas isso não é garantido - depende de como o sistema operacional agenda os threads. Nesta execução, o encadeamento principal é impresso primeiro, embora a instrução de impressão do encadeamento gerado apareça primeiro no código. Além disso, mesmo que o thread gerado seja programado para imprimir valores até 9, ele só chega a 5 antes de o thread principal desligar.

Alças de união

Um thread gerado pode não ter a chance de ser executado ou executado completamente. Isso ocorre porque o thread principal é concluído rapidamente. A função spawn <F, T> (f: F) -> JoinHandlelt; T> retorna um JoinHandle. O método join () em JoinHandle aguarda a conclusão do encadeamento associado.

use std::thread;
use std::time::Duration;

fn main() {
   let handle = thread::spawn(|| {
      for i in 1..10 {
         println!("hi number {} from the spawned thread!", i);
         thread::sleep(Duration::from_millis(1));
      }
   });
   for i in 1..5 {
      println!("hi number {} from the main thread!", i);
      thread::sleep(Duration::from_millis(1));
   }
   handle.join().unwrap();
}

Resultado

hi number 1 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the spawned thread!
hi number 2 from the main thread!
hi number 3 from the spawned thread!
hi number 3 from the main thread!
hi number 4 from the main thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!

O thread principal e o thread gerado continuam comutando.

NOTE - O encadeamento principal aguarda a conclusão do encadeamento gerado devido à chamada para o join() método.