Thread: Processo paralelo em Ruby/RGSS

[Fábio Pichler]

Thread: Processo paralelo em Ruby/RGSS
Por: Fábio Pichler

Atenção: Este tutorial é para Ruby e funciona em todas as versões do RGSS (RGSS, RGSS2 e RGSS3) do RPG Maker.


Introdução ao tutorial
Hoje vou mostrar um modo de executar tarefas em paralelo à execução principal, e pra isso, usaremos uma classe chamada Thread.
O processo paralelo ou simplesmente Thread, pode ser usado várias vezes ou podem ser usados, vários Threads ao mesmo tempo, mas tenha em mente que, quando mais processos estiverem rodando ao mesmo tempo, mais vai exigir do CPU e deixar o programa mais pesado.
Threads geralmente funcionam com um loop, onde o processo ficará rodando. Para finalizar o processo rodando em paralelo, basta encerrar o loop.

Veja na imagem, o resultado do meu teste:

Neste teste, usei dois Threads, no primeiro eu adicionei um loop infinito, enquanto no segundo, adicionei um loop com uma condição de encerrá-lo, quando uma variável alcançar um certo valor.
Este teste foi realizado no RPG Maker VX Ace, e não interferiu na execução do jogo, mesmo com um loop infinito dando um print na janela de console.


Utilizando um Thread
O modo de utilizar um Thread é muito fácil, basta usar a classe Thread, um loop e o seu código dentro do loop. O código poderá ficar rodando dentro do loop, sem afetar a execução principal.

A utilização da classe, é basicamente esta:

Thread.new {
  
  #Tudo será rodado aqui dentro.

}

Mas da forma acima, não ficará em execução, seu código será executado uma única vez (em paralelo) e o Thread será encerrado. Então para que possamos ter uma execução por mais tempo, devemos adicionar um loop, este loop pode ser encerrado, quando não for mais utilizar o processamento em paralelo.

Veja o código mais completo:

Thread.new {
  while(1)
    
    #Agora sim, temos um loop e o nosso código poderá ficar sendo executado, sem travar o programa.

  end
}

No código acima, adicionei um loop infinito, para deixar o código mais limpo, mas caso queira encerrar o processamento, basta adicionar uma condição ou usar um comando for, loop do, etc.


Alguns exemplos
Vamos fazer um teste? Se você está aprendendo a usar o Thread, suponho que já sabe como utilizar e rodar o Ruby, então vou direto ao ponto.
Se utiliza somente o Ruby, crie um arquivo de texto com qualquer nome e a extensão .rb e depois execute-o com o exemplo abaixo.
Se utiliza o RPG Maker, ative a Janela de Depuração e teste o exemplo abaixo. Coloque o script acima do main.

Thread.new {
  while(1)
    print "Exemplo de Thread\n" #Imprimindo uma mensagem.
    sleep(0.5) #Uma pequena pausa na execução.
  end
}

Neste próximo exemplo, teremos dois Threads, o primeiro é o mesmo de cima, o segundo possui uma condição para encerrá-lo.
O resultado deste exemplo, é aquela imagem que adicionei no começo do tutorial.

Thread.new {
  while(1)
    print "Primeiro Thread :D\n"
    sleep(0.5)
  end
}

Thread.new {
  var = 0
  while(var < 10) #Loop fica rodando, enquanto a variável for menor que dez. 
    print "Segundo Thread :)\n"
    sleep(0.5)
    var += 1 #Adiciona 1 à variável.
  end
  print "========== Fim do Segundo Thread ==========\n"
}

Usando uma Classe em processo paralelo
Veja como usar uma classe com o processamento através do Thread. Parece que meus testes deram certo.

#A classe que funcionará com Thread.
class TestThread
  def initialize
    @var1 = 3
    @var2 = 20
  end
  def update #Esta função ficará sempre atualizando.
    @var2 += @var1
    print @var2 #Imprime o resultado no console.
  end
end

Thread.new {
  test = TestThread.new #Criamos um objeto.
  while(1)
    test.update #Chamamos a função update da classe TestThread.
    sleep(0.5)
  end
}

Um exemplo mais completo de Classe
Neste último exemplo, mostrarei algo mais completo, com uma condição de encerrar o Thread.

class TestThread
  def initialize
    @var1 = 1
    @var2 = 14
  end
  def update
    @var2 += @var1
    if (@var2 < 25)
      print @var2.to_s + "\n" #Print até 24.
      return true #enquanto @var2 é menor que 25, retorna true.
    else
      return false #Caso contrário, retorna false.
    end
  end
  def terminate
    print "Thread encerrado!"
  end
end

Thread.new {
  test = TestThread.new #Criamos um objeto.
  while(test.update) #Chamamos a função update da classe TestThread.
    sleep(0.5)
  end
  test.terminate
}

Agora, enquanto a função update estiver retornando true, o loop ficará funcionando, caso retorne false, o loop será liberado.

Considerações finais
Achei bem legal, fazer este tutorial, me diverti escrevendo. :D Só não estou acostumado a escrever tutoriais, se tivesse, poderia ter ficado melhor.
Espero que alguém encontre utilidade no Thread, para usar no RPG Maker, já que não vejo scripts com ele.

Qualquer dúvida, só perguntarem. ;)


Créditos
Escrito por: Fábio Pichler.
Se for postar este tutorial em seu site, dê créditos a Fábio Pichler.
Post principal: Clique aqui.

[Makers]

Muito bom, gostei do tutorial ele explica muito bem cada
detalhe. Apesar de eu não trabalhar com RGSS eu acompanho os trabalhos.

Parabéns pelo tutorial