Threads e Closures em Groovy

Groovy é a mais famosa linguagem de scripts para Java. O Projeto é líder de implementação da especificação JSR 223 e ainda existe a proposta da JSR 241. Groovy é uma linguagem de script para a plataforma java que se caracteriza por prover:
- Agilidade e produtividade para o desenvolvimento.
- Interpolaridade total com Java.
- Suporte a Closures e Duck Typing.
- Adiciona features ao Java baseado em linguagens como o Python e Ruby.
- Dentre as features podemos destacar: Categories, GStrings e Builders.



Groovy é um linguagem de Scripts extremamente poderosa e ao mesmo tempo sem perder a diversão :). O Spring Framework já prove integração com Groovy. É possível injetar um bean Java em um Bean Groovy e vice-versa através do Spring. Vamos ver algumas coisas ingressantes em prática agora.

Após instalar o Groovy você pode digitar no console groovyconsole e uma tela como está deverá aparecer:


Esse é o console gráfico do Groovy, com ele podemos fazer teses e até mesmo scripts inteiros. No console existem alguns atalhos interessantes como:
CTRL + S : Salva o Script corrente.
CTRL + W: Limpa o resultado da execução.
CTRL + ENTER: Executa o Script Groovy.

Para testar podemos realizar uma simples impressão na tela, através do comando:
println 'teste'

Para criar uma lista basta fazer: lista = [1,2,3,4,5] .
Podemos iterar a lista com: lista.each{ println it }
É Fácil adicionar um elemento, simplesmente: lista <<>Agora vamos ver como poderíamos utilizar: Classes, Closures em conjunto com Threads, veja o seguinte Script abaixo que eu fiz:



Para executar o script basta digitá-lo no groovyconsole e digitar CTRL + ENTER. Você verá um resultado semelhante a esse:

Fatorial de 4 = 24
Fatorial de 5 = 120
Fatorial de 6 = 720

Fatorial de 3 = 6
Fatorial de 7 = 5040
Fatorial de 8 = 40320

Como estamos trabalhando com Threads é impossível predicar o resultado. Vamos ver o código mais de perto. Aqui:

new Thread({ println fatorial(fat)} as Runnable).start()
Estamos criando um objeto Runnable através de um Closure e estamos definindo o método run. Depois atribuímos o objeto Runnable a uma instância de Thread e já colocamos a Thread para executar.

Aqui:
fats.size.times{
eps.add(new Executor())
}
Estamos contando o tamanho do ArrayList chamado fats e supondo que o ArrayList tenha 3 de size, o closure a acima irá ser executado 3x. O que estamos fazendo é criar um Executor para cada elemento do ArrayList de Fatoriais, ou seja, existirá uma Thread para processar cada fatorial.

Aqui:
int i = 0
fats.each{ f ->
eps.get(i++).execute(f)
}
Estamos iterando todo o ArrayList de fatoriais e para cada elemento do ArrayList estamos guardando na variável f e pegando o Executor correspondente através de i e executando o calculo do fatorial passando o valor que desejamos calcular que está em f.

E no ponto mais divertido :)

def fatorial = { n ->
int fat = 1
for(i in n..2){
fat *= i
}
"Fatorial de $n = $fat"
}

Criei uma Closure para calcular o fatorial, defini que esse Closure ira receber um argumento como parâmetro. Esse argumento será chamado de n que representa o número que desejamos saber o fatorial. Agora estamos fazendo um for de i = n até 2 e multiplicando todos os valores e colocando em fat. Outro fator interessante do Groovy é que não é necessário utilizar a palavra reservada return para sinalizar o retorno, o Groovy assumi que a ultima linha será o retorno.

Até a próxima. :)

Popular posts from this blog

Telemetry and Microservices part2

Installing and Running ntop 2 on Amazon Linux OS

Fun with Apache Kafka