Threading in Clojure

http://de.wikipedia.org/wiki/Clojure

Clojure ist ein moderner Lisp-Dialekt, der interaktive Entwicklung unterstützt.
Die Sprache fördert einen funktionalen Stil, der nebenläufige Programmierung
stark vereinfacht. Clojure läuft in der Java Virtual Machine und ist eng mit der
Java Runtime integriert. Das Makrosystem ist mit dem anderer Lisp-Umgebungen vergleichbar.

Die Ameisenanimation

Die Ausgangsbedingung

Welt
- besteht aus Zellen, die nur in Transaktionen verändert werden können
Zelle
- enthält einen Betrag Nahrung und Duftstoff, eventuell eine Ameise und die zuhause Eigenschaft
Nahrung
- ist über die Welt verteilt
Ameisen
- sollen die Nahrung nach Hause bringen
- zwei Ameisen können nicht gleizeitig in einer Zelle sein
- Farbe der Ameise
  - schwarz: trägt keine Nahrung
  - rot: trägt Nahrung
  - besitzt eine Richtung und gegebenfalls Nahrung
- jede Ameisen fällt autonom die Entscheidung, wohin sie laufen soll;
  die Auswahl wird zufällig gewählt, hängt aber von folgenden Fragen ab
  1. Wie weit ist Zuhause entfernt?
  2. Wie hoch ist der Duftstoffgrad der benachbarten Zellen?
  3. Hat sie schon Nahrung?
  4. Ist eine andere Ameise in einer benachbarten Zelle?
Zuhause
- soll mit Nahrung aus der Welt gefüllt werden
Duftstoffe
- werden von den Ameisen verteilt um die Pfade zu etablieren
- verflüchtigen sich
Concurrency
- jede Ameise, die Animation (Graphik) als auch der Duftstoff wird durch einen Thread simuliert
- Aktionen geschehen nur in Transaktionen
- die neue Berechnung der Animation und der Duftstoffwerte wird über Nachrichten (Agenten) angestossen
Graphik (Java Besonderheiten)
- doto obj: wende die folgenden Methoden auf obj an
- (proxy [class][] function-definitions ... ): damit lässt sich eine Klasse class von Java in Clojure ableiten und implementieren

Ameisen in Aktion

Der Code

http://blip.tv/file/812787

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ant sim ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;   Copyright (c) Rich Hickey. All rights reserved.
;   The use and distribution terms for this software are covered by the
;   Common Public License 1.0 (http://opensource.org/licenses/cpl.php)
;   which can be found in the file CPL.TXT at the root of this distribution.
;   By using this software in any fashion, you are agreeing to be bound by
;   the terms of this license.
;   You must not remove this notice, or any other, from this software.

;dimensions of square world
(def dim 100)
;number of ants = nants-sqrt^2
;(def nants-sqrt 15)
(def nants-sqrt 10)
;number of places with food
(def food-places 80)
;range of amount of food at a place
(def food-range 100)
;scale factor for pheromone drawing
(def pher-scale 20.0)
;scale factor for food drawing
(def food-scale 30.0)
;evaporation rate
(def evap-rate 0.99)

(def animation-sleep-ms 100)
(def ant-sleep-ms 40)
(def evap-sleep-ms 1000)

(def running true)

(defstruct cell :food :pher) ;may also have :ant and :home

;world is a 2d vector of refs to cells
(def world
     (apply vector
            (map (fn [_]
                   (apply vector (map (fn [_] (ref (struct cell 0 0)))
                                      (range dim))))
                 (range dim))))

(defn place [[x y]]
  (-> world (nth x) (nth y)))

(defstruct ant :dir) ;may also have :food

(defn create-ant
  "create an ant at the location, returning an ant agent on the location"

  [loc dir]
    (sync nil
      (let [p (place loc)
            a (struct ant dir)]
        (alter p assoc :ant a)
        (agent loc))))

(def home-off (/ dim 4))
(def home-range (range home-off (+ nants-sqrt home-off)))

(defn setup
  "places initial food and ants, returns seq of ant agents"
  []
  (sync nil
    (dotimes [i food-places]
      (let [p (place [(rand-int dim) (rand-int dim)])]
        (alter p assoc :food (rand-int food-range))))
    (doall
     (for [x home-range y home-range]
       (do
         (alter (place [x y])
                assoc :home true)
         (create-ant [x y] (rand-int 8)))))))

(defn bound
  "returns n wrapped into range 0-b"
  [b n]
    (let [n (rem n b)]
      (if (neg? n)
        (+ n b)
        n)))

(defn wrand
  "given a vector of slice sizes, returns the index of a slice given a
  random spin of a roulette wheel with compartments proportional to
  slices."

  [slices]
  (let [total (reduce + slices)
        r (rand total)]
    (loop [i 0 sum 0]
      (if (< r (+ (slices i) sum))
        i
        (recur (inc i) (+ (slices i) sum))))))

;dirs are 0-7, starting at north and going clockwise
;these are the deltas in order to move one step in given dir
(def dir-delta {0 [0 -1]
                1 [1 -1]
                2 [1 0]
                3 [1 1]
                4 [0 1]
                5 [-1 1]
                6 [-1 0]
                7 [-1 -1]})

(defn delta-loc
  "returns the location one step in the given dir. Note the world is a torus"
  [[x y] dir]
    (let [[dx dy] (dir-delta (bound 8 dir))]
      [(bound dim (+ x dx)) (bound dim (+ y dy))]))

;(defmacro dosync [& body]
;  `(sync nil ~@body))

;ant agent functions
;an ant agent tracks the location of an ant, and controls the behavior of
;the ant at that location

(defn turn
  "turns the ant at the location by the given amount"

  [loc amt]
    (dosync
     (let [p (place loc)
           ant (:ant @p)]
       (alter p assoc :ant (assoc ant :dir (bound 8 (+ (:dir ant) amt))))))
    loc)

(defn move
  "moves the ant in the direction it is heading. Must be called in a
  transaction that has verified the way is clear"
  [loc]
     (let [oldp (place loc)
           ant (:ant @oldp)
           newloc (delta-loc loc (:dir ant))
           p (place newloc)]
         ;move the ant
       (alter p assoc :ant ant)
       (alter oldp dissoc :ant)
         ;leave pheromone trail
       (when-not (:home @oldp)
         (alter oldp assoc :pher (inc (:pher @oldp))))
       newloc))

(defn take-food [loc]
  "Takes one food from current location. Must be called in a
  transaction that has verified there is food available"
  (let [p (place loc)
        ant (:ant @p)]
    (alter p assoc
           :food (dec (:food @p))
           :ant (assoc ant :food true))
    loc))

(defn drop-food [loc]
  "Drops food at current location. Must be called in a
  transaction that has verified the ant has food"

  (let [p (place loc)
        ant (:ant @p)]
    (alter p assoc
           :food (inc (:food @p))
           :ant (dissoc ant :food))
    loc))

(defn rank-by
  "returns a map of xs to their 1-based rank when sorted by keyfn"
  [keyfn xs]
  (let [sorted (sort-by (comp float keyfn) xs)]
    (reduce (fn [ret i] (assoc ret (nth sorted i) (inc i)))
            {} (range (count sorted)))))

(defn behave
  "the main function for the ant agent"
  [loc]
  (let [p (place loc)
        ant (:ant @p)
        ahead (place (delta-loc loc (:dir ant)))
        ahead-left (place (delta-loc loc (dec (:dir ant))))
        ahead-right (place (delta-loc loc (inc (:dir ant))))
        places [ahead ahead-left ahead-right]]
    (. Thread (sleep ant-sleep-ms))
    (dosync
     (when running
       (send-off *agent* #'behave))
     (if (:food ant)
       ;going home
       (cond
        (:home @p)
          (-> loc drop-food (turn 4))
        (and (:home @ahead) (not (:ant @ahead)))
          (move loc)
        :else
          (let [ranks (merge-with +
                        (rank-by (comp #(if (:home %) 1 0) deref) places)
                        (rank-by (comp :pher deref) places))]
          (([move #(turn % -1) #(turn % 1)]
            (wrand [(if (:ant @ahead) 0 (ranks ahead))
                    (ranks ahead-left) (ranks ahead-right)]))
           loc)))
       ;foraging
       (cond
        (and (pos? (:food @p)) (not (:home @p)))
          (-> loc take-food (turn 4))
        (and (pos? (:food @ahead)) (not (:home @ahead)) (not (:ant @ahead)))
          (move loc)
        :else
          (let [ranks (merge-with +
                                  (rank-by (comp :food deref) places)
                                  (rank-by (comp :pher deref) places))]
          (([move #(turn % -1) #(turn % 1)]
            (wrand [(if (:ant @ahead) 0 (ranks ahead))
                    (ranks ahead-left) (ranks ahead-right)]))
           loc)))))))

(defn evaporate
  "causes all the pheromones to evaporate a bit"

  []
  (dorun
   (for [x (range dim) y (range dim)]
     (dosync
      (let [p (place [x y])]
        (alter p assoc :pher (* evap-rate (:pher @p))))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; UI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(import
 '(java.awt Color Graphics Dimension)
 '(java.awt.image BufferedImage)
 '(javax.swing JPanel JFrame))

;pixels per world cell
(def scale 5)

(defn fill-cell [#^Graphics g x y c]
  (doto g
    (.setColor c)
    (.fillRect (* x scale) (* y scale) scale scale)))

(defn render-ant [ant #^Graphics g x y]
  (let [black (. (new Color 0 0 0 255) (getRGB))
        gray (. (new Color 100 100 100 255) (getRGB))
        red (. (new Color 255 0 0 255) (getRGB))
        [hx hy tx ty] ({0 [2 0 2 4]
                        1 [4 0 0 4]
                        2 [4 2 0 2]
                        3 [4 4 0 0]
                        4 [2 4 2 0]
                        5 [0 4 4 0]
                        6 [0 2 4 2]
                        7 [0 0 4 4]}
                       (:dir ant))]
    (doto g
      (.setColor (if (:food ant)
                  (new Color 255 0 0 255)
                  (new Color 0 0 0 255)))
      (.drawLine (+ hx (* x scale)) (+ hy (* y scale))
                (+ tx (* x scale)) (+ ty (* y scale))))))

(defn render-place [g p x y]
  (when (pos? (:pher p))
    (fill-cell g x y (new Color 0 255 0
                          (int (min 255 (* 255 (/ (:pher p) pher-scale)))))))
  (when (pos? (:food p))
    (fill-cell g x y (new Color 255 0 0
                          (int (min 255 (* 255 (/ (:food p) food-scale)))))))
  (when (:ant p)
    (render-ant (:ant p) g x y)))

(defn render [g]
  (let [v (dosync (apply vector (for [x (range dim) y (range dim)]
                                   @(place [x y]))))
        img (new BufferedImage (* scale dim) (* scale dim)
                 (. BufferedImage TYPE_INT_ARGB))
        bg (. img (getGraphics))]
    (doto bg
      (.setColor (. Color white))
      (.fillRect 0 0 (. img (getWidth)) (. img (getHeight))))
    (dorun
     (for [x (range dim) y (range dim)]
       (render-place bg (v (+ (* x dim) y)) x y)))
    (doto bg
      (.setColor (. Color blue))
      (.drawRect (* scale home-off) (* scale home-off)
                 (* scale nants-sqrt) (* scale nants-sqrt)))
    (. g (drawImage img 0 0 nil))
    (. bg (dispose))))

(def panel (doto (proxy [JPanel] []
                        (paint [g] (render g)))
             (.setPreferredSize (new Dimension
                                     (* scale dim)
                                     (* scale dim)))))

(def frame (doto (new JFrame) (.add panel) .pack .show))

(def animator (agent nil))

(defn animation [x]
  (when running
    (send-off *agent* #'animation))
  (. panel (repaint))
  (. Thread (sleep animation-sleep-ms))
  nil)

(def evaporator (agent nil))

(defn evaporation [x]
  (when running
    (send-off *agent* #'evaporation))
  (evaporate)
  (. Thread (sleep evap-sleep-ms))
  nil)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; use ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(comment
;demo
(load-file "ants.clj")
(def ants (setup))
(send-off animator animation)
(dorun (map #(send-off % behave) ants))
(send-off evaporator evaporation)

)

Charakteristiken

Lisp Dialekt

Präfixnotation und Klammern
mächtiges Makrosystem Clojure besitzt einen kleine Sprachkern, der Rest wird über Makros implementiert

Funktionale Programmiersprache

Funktionen sind first-class functions (können Funktionen als Argument erhalten und zurückgeben)
Daten sind immutable (es gibt nur ausgewiesene veränderliche Daten (Referenztypen) für Concurrency mit einem expliziten Interface)
- Rekurssion als Strukturelement (kein desctructive update (++i) möglich)
- structural sharing für zusammengesetzte Datentypen Veränderungen der Daten erzeugen nur eine neue Sicht auf die Daten

Integration in die JVM

nutzt die Java Library Clojure besitzt die mächtigste Library
erzeugt Bytecode
Java Interfaces können in Clojure implementiert werden

Java Code kann sehr kompakt geschrieben werden

(import '(javax.swing JFrame JLabel JTextField JButton)
        '(java.awt.event ActionListener)
        '(java.awt GridLayout))
(defn celsius []
  (let [frame (JFrame. "Celsius Converter")
        temp-text (JTextField.)
        celsius-label (JLabel. "Celsius")
        convert-button (JButton. "Convert")
        fahrenheit-label (JLabel. "Fahrenheit")]
    (.addActionListener convert-button
      (proxy [ActionListener] []
        (actionPerformed [evt]
          (let [c (Double/parseDouble (.getText temp-text))]
            (.setText fahrenheit-label
               (str (+ 32 (* 1.8 c)) " Fahrenheit"))))))
    (doto frame
      (.setLayout (GridLayout. 2 2 3 3))
      (.add temp-text)
      (.add celsius-label)
      (.add convert-button)
      (.add fahrenheit-label)
      (.setSize 300 80)
      (.setVisible true))))
(celsius)

erzeugt: Celsius Convert:

Concurrency orientiert

setzt auf Javas Concurrency Fähigkeiten auf und bringt sie auf eine höhere Abstraktion
Daten sind immutable (Ausnahme Referenztypen und Java Typen)
Referenztypen (veränderliche Daten) sind über indirekte Referenzen implementiert die Referenz auf den veränderten Wert wird atomar umgebogen

Veränderliche Datentypen

Frech nach Clojure - Grundlagen, Concurrent Programming, Java

Die richtige Nutzung der Daten wird durch den Compiler sichergestellt.

Compilezeitfehler

Referenztyp	Kontext	Koordination	Ausführung
Var	lokal	eine Identität	synchron
Atom	global	eine Identität	synchron
Ref	global	mehrere Identitäten	synchron
Agent	globals	eine Identität	asynchron

das Lesen und Schreiben der Referenztypen muß explizit über Funktionsaufrufe erfolgen
nur Vars lassen sich implizit referenzieren
die Referenzentypen sind als indirekt Referenzen implementiert

bis auf Vars können die veränderlichen Datentypen mit Validatoren versehen werden

user=> (def myNum (atom 0 :validator integer?))
#'user/myNum
user=> (reset! myNum "Null")
java.lang.IllegalStateException: Invalid reference state (NO_SOURCE_FILE:0)
user=> (def myNewNum (atom "Null" :validator integer?))
java.lang.RuntimeException: java.lang.IllegalStateException: Invalid reference state (NO_SOURCE_FILE:4)

Thread lokale Daten - var

Veränderungen an Varssind nur Thread lokal sichtbar.

Vars als globale Variablen besitzt ein Root-Binding
wird die globale Variable modifiziert, erhält der modifizierte Thread eine thread-lokale Referenz auf diese Variable

Beispiel: Thread lokales Modifizieren von Daten

Code

(def *wert* "Root-Binding")

(defn thread1 []
  (println "Thread1-Root:" *wert*)
  (binding [*wert* "Lokal in Thread1"]
    (println "Thread1 binding vor sleep:" *wert*)
    (flush)
    (Thread/sleep 2000)
    (println "Thread1 binding nach sleep:" *wert*)))

(defn thread2 []
  (Thread/sleep 1000)
  (println "Thread2-Root:" *wert*)
  (binding [*wert* "lokal in Thread2"]
    (println "Thread2 binding: " *wert*)))

(do
  (.start (Thread. thread1))
  (.start (Thread. thread2)))

Ausgabe

user=> (load-file "var.clj")
Thread1-Root: Root-Binding
Thread1 binding vor sleep: Lokal in Thread1
nil
user=> Thread2-Root: Root-Binding
Thread2 binding:  lokal in Thread2
Thread1 binding nach sleep: Lokal in Thread1

Operationen

Operation	Erläuterung
def	erzeugen einer Var

Atomare Variablen - atom

Atomekoordinieren Thread-übergreifend Lesen und Schreiben.

verwendet unter der Decke java.util.concurrent.atomic
im Konfliktfall wird die Veränderung des Atoms neu durchgeführt
die Updatefunktion sollte keine Nebeneffekte erzeugen

Beispiel: Herunterzählen eines Countdowns

Code

(def countdown (atom 1000))

(def aufrufe (atom 0))

(defn tick [akt-wert]
  (swap! aufrufe inc)
  (dec akt-wert))

(do
 (dotimes [ _ 1000]
  (.start
    (Thread.
      #(swap! countdown tick)))))

Ausgabe

user=> (load-file "atom.clj")
nil
user=> @countdown
0
user=> @aufrufe
1014

Operationen

Operation	Erläuterung
atom	erzeugen eines Atoms
deref, @	lesen des Wertes
reset!	setzen eines neuen Wertes
swap!	schreiben eines Wertes über eine Updatefunktion
compare-and-set!	bedingtes schreiben eines Wertes

Software Transactional Memory

Refserlauben das konsistente Verändern mehrerer Atome.

setzt Transaktionen aus dem Datenbankbereich auf den Speicherbereich umzusetzen (ACID)
- A atomic: operationen auf den Daten erfolgen atomar
- C consistent: die Daten in einer Transaktion sind immer in einem konsistenten Zustand
- I isolated: Änderungen an den Daten sind ausserhalb der Transaktion nicht sichtbar, bevor die Transaktion nicht erfolgreich beendet wird
- D durable: Daten sind nach der Transaktion auf einem Medium gesichert
ACI wird in Software Transaktional Memory umgesetzt
am Ende der Transaktion wird die Änderung veröffentlicht, falls keine anderen Transaktionen auf den Daten wirken (optimistischer Ansatz im Gegensatz zu Locks)
- im Kollisionsfall muß die Transaktionen ihre Arbeit erneut aufnehmen (in Transaktionen dürfen keine Seiteneffekte geschehen)
falls eine andere Transaktion in Clojure einen Wert nur liest, führt dies nicht zum erneuten Aufruf einer Transaktion (Ausnahme ensure)
Transaktionen stellen eine hohe Anforderungen an Speicher und CPU gegenüber Locks, da jede Transaktion eine Kopie der Daten hält
Clojure lässt nur eine maximale Anzahl an Wiederholungen je Transaktion aus (1000)

Beispiel: Lesend und Schreiben in einer Transaktion

Code

(def ref1 (ref 1 ))

(def ref2 ( ref 1 ))

(defn lesethread []
  (println "Thread 1: lese ")
  (dotimes [i 6 ]
    (Thread/sleep 100)
    (dosync
      (println "ref1: " @ref1 "ref2: " @ref2))))

(defn schreibthread[]
  (println "Thread2: schreibe")
  (dosync
    (alter ref1 inc)
    (Thread/sleep 300)
    (alter ref2 inc)))

(do
  (.start (Thread. lesethread))
  (.start (Thread. schreibthread)))

Ausgabe

user=> (load-file "ref.clj")
Thread 1: lese
nilThread2: schreibe

user=> ref1:  1 ref2:  1
ref1:  1 ref2:  1
ref1:  1 ref2:  1
ref1:  2 ref2:  2
ref1:  2 ref2:  2
ref1:  2 ref2:  2

Operationen

Operation	Erläuterung
ref	erzeugen einer Referenz
dosync, io!	erzeugen einer Transaktion
deref, @	lesen einer Referenz
ensure	setzen eines neuen Wertes Wert kann in anderen Transaktionen nicht verändert werden
ref-set	setzen eines Wertes
alter	schreiben eines Wertes über eine Updatefunktion
commute	schreiben eines Wertes über eine Updatefunktion Werte in Transkationen dürfen sich überschreiben (last wins)

Message Passing - agent

Agentsarbeiten asynchron und seriell.

die Berechnung der Werte, die einem Agenten übermittel werden, geschieht in einem anderen Thread
die Updatefunkton wird als Aktion bezeichnet
Agentenaufrufe integrieren sich in das Transaktionssystem
während des Aktormodell in Erlang Nachrichten zwischen Prozessen übermittelt, arbeitet das Agentenmodell über Threads in einem Prozeß
über await oder await-for wird der aufrufende Thread blockiert

Beispiel: Befüllen eines Vektors mit Strings

Code

(def agts (agent ["James Bond"]))

(defn gehaltsliste-Überwachen []
  (dotimes [i 10]
    (println i "Anzahl Agenten: " (count @agts ))
    (Thread/sleep 2)))

(defn agenten-einstellen []
  (let [agenten ["Jerry Cotton"

                 "Phil Decker"
                 "John Steed"
                 "Emma Peel"
                 "Austing Powers"]]
    (doseq [a agenten]
      (send agts conj a)
      (println "Gesendet" a " -> " @agts)
      (Thread/sleep 2))))

(do
  (.start (Thread. gehaltsliste-Überwachen))
  (.start (Thread. agenten-einstellen)))

Ausgabe

user=> (load-file "agent.clj")
0 Anzahl Agenten:  1
1 Anzahl Agenten:  1
nil
user=> 2 Anzahl Agenten:  1
Gesendet Jerry Cotton  ->  3 Anzahl Agenten:  2
[James Bond Jerry Cotton]
4 Anzahl Agenten:  2
Gesendet Phil Decker  ->  [James Bond Jerry Cotton Phil Decker]
5 Anzahl Agenten:  3
6 Anzahl Agenten:  3
Gesendet John Steed  ->  [James Bond Jerry Cotton Phil Decker John Steed]
7 Anzahl Agenten:  4
Gesendet Emma Peel  ->  [James Bond Jerry Cotton Phil Decker John Steed Emma Peel8 Anzahl Agenten:  5
]
9 Anzahl Agenten:  5
Gesendet Austing Powers  ->  [James Bond Jerry Cotton Phil Decker John Steed Emma Peel Austing Powers]

user=>

Operationen

Operation	Erläuterung
agent	erzeugen eines Agenten
deref, @	lesen einer Agenten
send	wendet die nicht blockierende update Funktion (Aktion)auf den Agent an
send-off	wendet die potenziell blockierende update Funktion (Aktion) auf den Agent an
restart-agent	setzt den Agent zurück
await	blockieren des aufrufenden Thread
await-for	blockieren des aufrufenden Thread für Millisekunden
shutdown-agents	schliesst den Threadpool aller Agenten