Agents

agent-overview.clj

;; aqui eu crio um agent com o valor 1 e chamo de x
(def y (agent 1))

;; nossa função vai levar dez segundos a cada processamento
(defn triple [c]
  (println "valor inicial:" c)
  (Thread/sleep 10000)
  (println "terminei")
  (* c 3))

;; usamos deref ou @ para pegar o valor atual
@y
; 1

;; vamos executar a função uma vez. vai levar dez segundos para terminar
(send y triple)
; valor inicial: 1
; #<Agent@766b9d4c: 1>

;; antes dos dez segundos, vamos ver o valor de y
@y
; 1

;; passados dez segundos

; terminei
@y
; 3

;; note que a nossa thread atual, a que contém o prompt do REPL
;; não travou enquanto triple executava, mesmo quando quisermos
;; ver o valor de y. Agents são assíncronos de verdade.

;; agora vamos mandar rodar triple dez vezes no mesmo agent.

(repeatedly 10 #(send y triple))
; valor inicial: 3
; (#<Agent@766b9d4c: 3> #<Agent@766b9d4c: 3> #<Agent@766b9d4c: 3> #<Agent@766b9d4c: 3> #<Agent@766b9d4c: 3> #<Agent@766b9d4c: 3> #<Agent@766b9d4c: 3> #<Agent@766b

;; e voltou ao prompt do REPL

;; dez segundos depois:
; terminei
; valor inicial: 9

;; mais dez segundos
; terminei
; valor inicial: 27

;; e assim por diante, até calcular as 10 vezes

@y
; 177147

;; Nisso podemos aprender algumas coisas:
;; - agents são verdadeiramente assíncronos. ficamos livres para continuar trabalhando enquanto o processamento ocorre.
;; - agents enfileiram as ordens. mandamos executar dez processamentos em um agent e os dez ocorreram em ordem
;; - agents são muito legais