Trabalhando com Threads em Ruby
Tags: ruby, rails, braziliandevs, backend
Published: 2023-09-27 20:01:05

Na medida que você avança na sua carreira em programação, eficiência e desempenho se tornam uma preocupação cada vez maior em seus sistemas. Threads é uma ferramenta poderosíssima, que expande a liberdade de um desenvolvedor utilizando ao máximo o poder de processamento de seus sistemas. Então, não, não estamos falando sobre a rede social Threads hahah, Threads será um conhecimento que você, programador, não vai querer deixar de lado.

## **Sumário**

- [**Sumário**](#sumário)
- [**O que são threads?**](#o-que-são-threads)
- [**Exemplo de uso prático**](#exemplo-de-uso-prático)
- [**Variáveis de Thread**](#variáveis-de-thread)
- [**Usando RequestStore**](#usando-requeststore)
- [**Conclusão**](#conclusão)
- [Referências](#referências)


## **O que são threads?**

Para aqueles que não estão familiarizados com o conceito de threads: em resumo, imagine que as threads são como funcionários em uma empresa. Quatro funcionários podem colaborar para realizar a mesma tarefa, mas cada um pode ser responsável por uma atividade diferente e específica. Seu sistema também pode realizar várias tarefas ao mesmo tempo, usando essa ferramenta poderosa.

## **Exemplo de uso prático**

* **Exportação de Dados**: Pense na funcionalidade do LinkedIn para exportar todos os dados da sua conta ou na função em aplicativos de mensagens como WhatsApp e Telegram. Seria problemático para os usuários terem que esperar em uma tela específica, assim como seria problemático para o sistema lidar com muitos usuários decidindo exportar um grande volume de dados simultaneamente.

* **Requisições Concorrentes** : Você também pode dividir suas solicitações em várias threads para otimizar o tempo e a eficiência do seu sistema para um cliente.

* **Controle de Fluxo de Dados**: Em casos mais avançados, lembre-se de que em sistemas de banco de dados relacionais, uma alteração pode afetar outros dados em seu sistema. É possível acompanhar quantas/quais solicitações foram feitas acompanhando as threads.

Para demonstrar como isso pode ser implementado no contexto do Ruby, dê uma olhada no exemplo abaixo:


```ruby
class TasksController < ApplicationController
  def process_emails
    # Create a thread to process emails in the background
    Thread.new do
      # Logic for sending emails
      sleep(5)
      puts "Emails processados com sucesso!"
    end

    # Return an immediate response to the user
    render plain: "Processando emails em segundo plano..."
  end
end
```

## **Variáveis de Thread**

Uma maneira de ter um melhor controle dentro de uma thread é usar variáveis. Isso é útil quando você precisa fazer alterações específicas dentro dessa thread. Exemplo de como criar variável:

```ruby
Thread.current[:foo] ||= 0
```
Um problema recorrente, é importante observar que o valor da thread pode persistir por mais tempo do que desejado. Lidar com threads pode ser complicado, e pode acontecer que o valor definido em "foo" ainda esteja presente em usos futuros da thread. Para evitar problemas, especialmente se você precisar salvar essas variáveis apenas durante uma sequência de requisições, você pode usar a gem "RequestStore", que lida com isso facilmente:

## **Usando RequestStore**

Para definir a variável:

```ruby
RequestStore.store[:foo] ||= 0
```
Para acessar a variável:

```ruby
RequestStore.fetch[:foo]
```
`RequestStore` é uma gem útil para gerenciar variáveis locais de thread e garantir um escopo adequado. Você pode encontrar mais informações e acessar o código em seu [repositório do github](https://github.com/steveklabnik/request_store). `RequestStore` é um software de código aberto lançado sob a Licença MIT.

## **Conclusão**

Trabalhar com threads em Ruby oferece uma maneira eficaz de lidar com tarefas concorrentes, melhorando a eficiência e a capacidade de resposta do sistema. No entanto, é essencial ter cuidado ao gerenciar variáveis de thread para evitar problemas de persistência. O uso de ferramentas como o "RequestStore" pode tornar esse controle mais fácil. Com uma compreensão adequada desses conceitos, você pode otimizar eficaz e eficientemente a execução de tarefas em sua aplicação Ruby.


## Referências

- [`Documentação Oficial sobre Threads`](https://ruby-doc.org/core-3.0.0/Thread.html)
- [`Repositório da RequestStore no github`](https://github.com/steveklabnik/request_store)