�ݺ�ߣ

Programowanie funkcjonalne
funkcyjnie z Clojure praktycznie
O budowaniu współbieżnej aplikacji graﬁcznej

Jacek Laskowski
jacek@japila.pl
http://www.JacekLaskowski.pl
wersja 1.0, 12.05.2011

Ja...cek Laskowski
• Entuzjasta Java EE, OSGi, SCA oraz programowania funkcyjnego (Clojure)

• Założyciel i lider Warszawa JUG

• Organizator Conﬁtura 2011

• Członek zespołu NetBeans DreamTeam

• Blogger na http://JacekLaskowski.pl

• Blogger na http://blog.japila.pl

• Twittuje jako @jaceklaskowski

• Członek zespołów Apache Geronimo i Apache OpenEJB

• Specjalista produktów IBM WebSphere w IBM Polska

konferencja społeczności javowej w Polsce

Conﬁtura 2011
http://conﬁtura.pl
11 czerwiec
Warszawa
(poprzednio Javarsovia)

infoShare 2011 - Jacek Laskowski - Programowanie Funkcjonalne Funkcyjnie z Clojure Praktycznie

Źródła inspiracji
• Programming Concurrency on the JVM: Mastering
Synchronization, STM, and Actors
http://www.jaceklaskowski.pl/wiki/
Book_review:_Programming_Concurrency_on_the_JVM

• Java Concurrency in Practice
http://jcip.net

$ java -version
java version "1.6.0_24"
Java(TM) SE Runtime Environment (build 1.6.0_24-b07-334-10M3326)
Java HotSpot(TM) 64-Bit Server VM (build 19.1-b02-334, mixed mode)

$ clj
user=> (clojure-version)
"1.3.0-alpha6"

user=> ; przestrzeń nazewnicza (ang. namespace) w Clojure
user=> ; mapa symboli na ich odpowiedniki pełne - odnośniki i klasy
user=> (ns gui)
nil
gui=>
gui=> (def nazwa-konferencji "InfoShare")
#'gui/nazwa-konferencji
gui=> (import javax.swing.JFrame)
javax.swing.JFrame
gui=> (use 'clojure.contrib.swing-utils)
nil
gui=> (ns-interns 'gui)
{nazwa-konferencji #'gui/nazwa-konferencji}

gui=> (import (javax.swing JFrame JButton JTextField JOptionPane))
javax.swing.JOptionPane
gui=> (import (java.awt GridLayout))
java.awt.GridLayout
gui=> (use '[clojure.contrib.swing-utils :only (add-action-listener)])
nil

gui=> (JFrame. nazwa-konferencji)
#<JFrame javax.swing.JFrame
[frame1,0,22,0x0,invalid,hidden,layout=java.awt.BorderLayout,title=Info
Share,resizable,normal,defaultCloseOperation=HIDE_ON_CLOSE,ro
otPane=javax.swing.JRootPane[,
0,0,0x0,invalid,layout=javax.swing.JRootPane
$RootLayout,alignmentX=0.0,alignmentY=0.0,border=,ﬂags=16777673,
maximumSize=,minimumSize=,preferredSize=],rootPaneCheckingEnabl
ed=true]>

gui=> (def f (JFrame. nazwa-konferencji))
#'gui/f
gui=> (doto f
.pack
.show)
#<JFrame javax.swing.JFrame
[frame2,0,22,128x37,layout=java.awt.BorderLayout,title=InfoShare,resiz
able,normal,defaultCloseOperation=HIDE_ON_CLOSE,rootPane=java
x.swing.JRootPane[,0,22,128x15,layout=javax.swing.JRootPane
$RootLayout,alignmentX=0.0,alignmentY=0.0,border=,ﬂags=16777673,
maximumSize=,minimumSize=,preferredSize=],rootPaneCheckingEnabl
ed=true]>

gui=> (.setSize f 600 300)
nil

gui=> (def word-input-field (JTextField. 30))
#'gui/word-input-field
gui=> (defn create-enter-handler [input-field]
(fn enter-handler
[event]
(let [w (.. input-field getText)
msg (format "<html>Input: <b>%s</b></html>" w)]
(do
(JOptionPane/showMessageDialog nil msg "Information"
JOptionPane/INFORMATION_MESSAGE)
(.. input-field (requestFocusInWindow))
(.. input-field (selectAll))))))
#'gui/create-enter-handler

gui=> (add-action-listener word-input-field (create-enter-handler
word-input-field))
#<Object$ActionListener$46793e3a clojure.contrib.swing_utils.proxy
$java.lang.Object$ActionListener$46793e3a@50152643>
gui=> (.add f word-input-field)
#<JTextField javax.swing.JTextField[...]>
gui=> (.pack f)
nil

Programming Concurrency on the JVM, page 18

Programming Concurrency on the JVM, page 22

Model pamięci Java
Memory barrier

• Clojure jest językiem funkcyjnym

• Clojure hołduje funkcjom czystym (ang. pure functions)

• Tożsamość (ang. identity) = logiczny byt, symbol

• Stan (ang. state) = wartość

• Czas (ang. time) = migawka

• Clojure oddziela tożsamość od stanu = upraszcza współbieżność

�²��ół��ż�Դ�ść
vs
wielowątkowość

Sztandarowy program współbieżny
w Clojure
ants.clj
http://paste.lisp.org/display/81878/raw

$ wc ants.clj
319 1323 9727 ants.clj

$ grep Thread ants.clj
(. Thread (sleep ant-sleep-ms))
(. Thread (sleep animation-sleep-ms))
(. Thread (sleep evap-sleep-ms))

$ clj
Clojure 1.3.0-alpha6
user=> (load-ﬁle "ants.clj")
nil

user=> (def ants (setup))
#'user/ants
user=> (send-off animator animation)
#<Agent@12dfbabd: nil>

user=> (dorun (map #(send-off % behave) ants))
nil

Clojure a stan
• 4 rodzaje referencji (odwołań do pamięci) w Clojure

• Vars - dynamiczna referencja do zmiennej wartości (per wątek)

• Refs - transakcyjny Var dla wielu wątków

• Agents - asynchroniczny i niezależny

• Atoms - synchroniczny i niezależny stan

$ grep agent ants.clj
"create an ant at the location, returning an ant agent on the location"
(agent loc))))
"places initial food and ants, returns seq of ant agents"
;ant agent functions
;an ant agent tracks the location of an ant, and controls the behavior of
"the main function for the ant agent"
(send-off *agent* #'behave))
(def animator (agent nil))
(send-off *agent* #'animation))
(def evaporator (agent nil))
(send-off *agent* #'evaporation))

$ grep ref ants.clj
;world is a 2d vector of refs to cells
(apply vector (map (fn [_] (ref (struct cell 0 0)))
(rank-by (comp #(if (:home %) 1 0) deref) places)
(rank-by (comp :pher deref) places))]
(rank-by (comp :food deref) places)
(rank-by (comp :pher deref) places))]
(.setPreferredSize (new Dimension

user=> (doc future)
-------------------------
clojure.core/future
([& body])
Macro
Takes a body of expressions and yields a future object that will
invoke the body in another thread, and will cache the result and
return it on all subsequent calls to deref/@. If the computation has
not yet ﬁnished, calls to deref/@ will block.

user=> (source future-cancel)
(defn future-cancel
"Cancels the future, if possible."
{:added "1.1"
:static true}
[^java.util.concurrent.Future f] (.cancel f true))

user=> (doc pmap)
-------------------------
clojure.core/pmap
([f coll] [f coll & colls])
Like map, except f is applied in parallel. Semi-lazy in that the
parallel computation stays ahead of the consumption, but doesn't
realize the entire result unless required. Only useful for
computationally intensive functions where the time of f dominates
the coordination overhead.
user=> (doc pcalls)
-------------------------
clojure.core/pcalls
([& fns])
Executes the no-arg fns in parallel, returning a lazy sequence of
their values

clojure.lang.Agent
user=> (source agent)
(defn agent
...
([state & options]
(let [a (new clojure.lang.Agent state)
opts (apply hash-map options)]
(setup-reference a options)
(when (:error-handler opts)
(.setErrorHandler a (:error-handler opts)))
(.setErrorMode a (or (:error-mode opts)
(if (:error-handler opts) :continue :fail)))
a)))

$ javap -classpath clojure.jar clojure.lang.Agent
Compiled from "Agent.java"
public class clojure.lang.Agent extends clojure.lang.ARef{
java.util.concurrent.atomic.AtomicReference aq;
public static ﬁnal java.util.concurrent.ExecutorService
pooledExecutor;
public static ﬁnal java.util.concurrent.ExecutorService soloExecutor;
public java.lang.Object dispatch(clojure.lang.IFn, clojure.lang.ISeq,
boolean);
static void dispatchAction(clojure.lang.Agent$Action);
void enqueue(clojure.lang.Agent$Action);
public int getQueueCount();
public static int releasePendingSends();
...

clojure.lang.Atom
user=> (source atom)
(defn atom
...
([x] (new clojure.lang.Atom x))
([x & options] (setup-reference (atom x) options)))

clojure.lang.Ref
user=> (source ref)
(defn ref
...
([x] (new clojure.lang.Ref x))
([x & options]
(let [r ^clojure.lang.Ref (setup-reference (ref x) options)
opts (apply hash-map options)]
(when (:max-history opts)
(.setMaxHistory r (:max-history opts)))
(when (:min-history opts)
(.setMinHistory r (:min-history opts)))
r)))

�ݺ�ߣ

infoShare 2011 - Jacek Laskowski - Programowanie Funkcjonalne Funkcyjnie z Clojure Praktycznie

More Related Content

infoShare 2011 - Jacek Laskowski - Programowanie Funkcjonalne Funkcyjnie z Clojure Praktycznie