Threads com Spring Boot

Olá, Luccas! Tudo joia?

No Spring Boot, o uso de threads pode ser gerenciado de várias maneiras, especialmente quando se trata de simular transações bancárias que envolvem a modificação do saldo de usuários. Vou te dar uma visão geral de como isso pode ser feito.

1. Uso de @Async

   O Spring Boot oferece uma anotação chamada @Async que permite executar métodos de forma assíncrona. Para usar essa anotação, você precisa habilitar o suporte a tarefas assíncronas em sua aplicação.

   Primeiro, habilite a execução assíncrona em sua classe de configuração:

   import org.springframework.context.annotation.Configuration;
   import org.springframework.scheduling.annotation.EnableAsync;
   
   @Configuration
   @EnableAsync
   public class AsyncConfig {
   }
   

   Em seguida, você pode criar um serviço para realizar a transferência bancária:

   import org.springframework.scheduling.annotation.Async;
   import org.springframework.stereotype.Service;
   
   @Service
   public class TransferService {
   
       @Async
       public void transfer(String fromAccount, String toAccount, double amount) {
           // Lógica para realizar a transferência
           // Exemplo:
           // 1. Subtrair o valor da conta de origem
           // 2. Adicionar o valor à conta de destino
           // 3. Salvar as alterações no banco de dados
       }
   }
   

   Chame o método transfer de forma assíncrona:

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.web.bind.annotation.PostMapping;
   import org.springframework.web.bind.annotation.RequestParam;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class TransferController {
   
       @Autowired
       private TransferService transferService;
   
       @PostMapping("/transfer")
       public String transfer(@RequestParam String fromAccount, @RequestParam String toAccount, @RequestParam double amount) {
           transferService.transfer(fromAccount, toAccount, amount);
           return "Transfer initiated";
       }
   }
   

2. Gerenciamento de Transações

   Para garantir que as operações de transferência sejam atômicas (ou seja, todas as etapas da transferência sejam concluídas com sucesso ou nenhuma delas seja aplicada), você pode usar a anotação @Transactional:

   import org.springframework.transaction.annotation.Transactional;
   
   @Service
   public class TransferService {
   
       @Async
       @Transactional
       public void transfer(String fromAccount, String toAccount, double amount) {
           // Lógica para realizar a transferência com transações
       }
   }
   

3. Sincronização de Threads

   Se você precisar garantir que duas threads não modifiquem o saldo ao mesmo tempo, pode usar a sincronização. No entanto, isso deve ser feito com cuidado para evitar deadlocks e outros problemas de concorrência.

   @Service
   public class TransferService {
   
       private final Object lock = new Object();
   
       @Async
       @Transactional
       public void transfer(String fromAccount, String toAccount, double amount) {
           synchronized (lock) {
               // Lógica para realizar a transferência
           }
       }
   }
   

Esses são alguns dos métodos que você pode usar para gerenciar threads e transações no Spring Boot. Cada abordagem tem suas próprias vantagens e desvantagens, então escolha a que melhor se adapta às suas necessidades.

Espero ter ajudado e bons estudos!