As APIs de threads do Rust não parecem muito diferentes das de C++.

Execute o exemplo.

• O tempo de 5ms é suficientemente folgado para que a thread principal e as threads filhas permaneçam principalmente em sincronia.
• Observe que o programa termina antes que a thread filha alcance 10!
• Isso ocorre porque o main termina o programa e as threads filhas não o mantêm.
  • Compare com pthreads/C++ std::thread/boost::thread se desejar.

Como esperamos a thread filha terminar?

thread::spawn retorna um JoinHandle. Veja a documentação.

• JoinHandle tem um método .join() bloqueante.

Use let handle = thread::spawn(...) e depois handle.join() para esperar que a thread termine e fazer o programa contar até 10.

Agora, e se quisermos retornar um valor?

Olhe a documentação novamente:

• O encerramento de thread::spawn retorna T
• JoinHandle .join() retorna thread::Result<T>

Use o valor de retorno Result de handle.join() para obter acesso ao valor retornado.

Ok, e quanto ao outro caso?

• Dispare um panic na thread. Observe como isso não afeta main.
• Acessa o payload do panic. Este é um bom momento para falar sobre Any.

Agora podemos retornar valores de threads! E quanto a receber entradas?

• Capture algo por referência no encerramento da thread.
• Uma mensagem de erro indica que devemos movê-lo.
• Mova-o, veja que podemos calcular e depois retornar um valor derivado.

E se quisermos emprestar?

• O main mata as threads filhas quando retorna, mas outra função apenas retornaria e as deixaria em execução.
• Isso seria acesso após retorno da pilha, o que viola a segurança de memória!
• Como evitamos isso? Veja o próximo slide.