Futuros de Scala

Às vezes, ao realizar cálculos complexos, esperamos que nossos programas executem tarefas diferentes simultaneamente por ter uma velocidade e eficiência melhor. Esse conceito desempenha um papel vital, especialmente quando não queremos as tarefas que consomem tempo para bloquear todo o nosso processamento. Na linguagem de programação do Scala, a funcionalidade dos threads pode ser alcançada usando o futuro do Scala e aprenderemos mais sobre eles neste artigo.

Quais são os futuros de Scala e qual é o objetivo de usá -los?

Afirmamos na introdução que os futuros de Scala servem ao mesmo objetivo que os threads em qualquer outra linguagem de programação i.e., simultaneidade. Isso significa que, ao criar um futuro scala para qualquer tarefa que deve demorar mais do que o habitual para executar, você pode executar outras tarefas em paralelo. Isso economizará seu tempo de computação sem bloquear o fluxo normal do seu programa.

Exemplos de uso de futuros de Scala

Se você deseja usar o Futures Scala no Ubuntu 20.04, os dois exemplos a seguir o ajudarão bem a fazer isso.

Exemplo # 1: Introdução com futuros de Scala

Neste exemplo, queremos apenas compartilhar com você a sintaxe geral de usar o Scala Futures. Para aprender isso, você precisa dar uma olhada no código Scala mostrado abaixo:

Para usar o Futures Scala, você primeiro precisa importar as duas bibliotecas necessárias i.e., “Scala.simultâneo._ ”E“ scala.simultâneo.ExecutionContext.Implícitos.global". Depois de importar essas bibliotecas, a próxima coisa que você precisa fazer é criar uma classe executável. Criamos uma classe chamada "teste" com a ajuda da palavra -chave "objeto". Então, dentro desta classe executável, criamos uma função de driver "main ()" dentro da qual criamos um valor chamado "FUT". Então, atribuímos a ele um futuro scala. Dentro deste futuro, queríamos executar duas tarefas diferentes.

Devido à primeira tarefa, estamos basicamente colocando nosso programa para dormir por 1 segundo. Então, queríamos calcular o resultado da declaração "21 + 21". No entanto, gostaríamos de afirmar aqui que esta segunda tarefa só será executada após a primeira declaração concluir sua execução. Então, queríamos imprimir o resultado da variável "FUT". Este resultado retornará "não concluído" se a execução do futuro acima mencionado ainda estará pendente; Caso contrário, o resultado da segunda declaração será calculado. Portanto, ambas as tarefas serão concluídas com sucesso. Por fim, queríamos imprimir uma mensagem no terminal que notificará o usuário de que a execução desta função está parcialmente concluída.

Poderemos executar este script Scala apenas uma vez que ele for compilado com sucesso, o que pode ser feito com o seguinte comando:

$ Scalac Futures.Scala

Depois que este script Scala será bem compilado, podemos executá -lo com o comando mostrado abaixo:

Teste de $ scala

A saída produzida por este script scala é mostrada na imagem a seguir. Isso descreveu o uso de futuros de Scala no Ubuntu 20.04.

Exemplo # 2: Executando duas tarefas independentes- uma com os futuros do Scala e outro normalmente

Agora, daremos um passo adiante explicando a você um exemplo prático de usar o Scala Futures no Ubuntu 20.04. Neste exemplo, estaremos executando duas tarefas diferentes. O primeiro será realizado usando o futuro da Scala, enquanto o segundo será executado normalmente. Projetamos intencionalmente a primeira tarefa de uma maneira que sua execução levará algum tempo. É exatamente por isso que fechamos esta tarefa no futuro da Scala. No entanto, no que diz respeito à segunda tarefa, ela foi projetada de uma maneira que será executada rapidamente. Dessa forma, receberemos a saída da segunda tarefa antes de receber a saída da primeira tarefa. Para entender essa funcionalidade, você terá que conferir o script Scala mostrado abaixo:

Novamente, neste script Scala, primeiro importamos as duas bibliotecas necessárias. Em seguida, criamos a classe de motorista e a função do motorista da mesma maneira que fizemos no exemplo acima. Depois disso, criamos um valor chamado "FUT". Para isso, atribuímos o futuro da Scala, no qual usamos um tópico que chamará a função "Sleep" para um segundo. Em seguida, criamos um valor chamado "x" e atribuímos a ele o resultado da declaração "2+2". Depois disso, queríamos imprimir esse valor no terminal e, em seguida, imprimir uma mensagem de que a segunda tarefa eu.e., O cálculo de "x" foi concluído com sucesso. Então, queríamos imprimir o valor da variável "FUT" que dependerá da execução do nosso futuro Scala. Por fim, queríamos imprimir uma mensagem no terminal para notificar o usuário de que agora, a primeira tarefa também foi concluída.

Após a compilação e execução deste script Scala, a seguinte saída apareceu no terminal. Nesta saída, primeiro, o resultado de nossa segunda tarefa i.e., 2+2 foi impresso no terminal que é "4". Então, fomos notificados de que a segunda tarefa foi executada com sucesso. Depois disso, o resultado de nosso "futuro" foi impresso no terminal seguido por outra mensagem de sucesso.

Conclusão

Queríamos apresentá -lo ao conceito de futuros de Scala no Ubuntu 20.04 com a ajuda deste guia. Primeiro, compartilhamos com você o que são futuros de Scala e como eles se relacionam com o conceito de threads e simultaneidade. Depois disso, estabelecemos uma boa compreensão dos futuros de Scala, declarando o objetivo de usá -los. Em seguida, implementamos dois exemplos muito básicos que fizeram uso desse importante conceito na linguagem de programação da Scala para alcançar a simultaneidade. Com a ajuda deste guia e esses exemplos, você pode implementar exemplos mais complexos nos quais poderá executar várias tarefas simultaneamente com a ajuda do Scala Futures.