Esempio di componibilità della memoria transazionale del software

Uno dei principali vantaggi della memoria transazionale del software che viene sempre menzionato è la componibilità e la modularità. Frammenti diversi possono essere combinati per produrre componenti più grandi. Nei programmi basati su lock, spesso non è così.

Sto cercando un semplice esempio che illustra questo con il codice attuale. Preferirei un esempio in Clojure, ma anche Haskell sta bene. Punti bonus se l'esempio mostra anche un codice basato su lucchetto che non può essere composto facilmente.

haskell clojure stm

— dbyrne
fonte

Interessante, ma mi sembra più una domanda StackOverflow.

— Steve,

Questa domanda è stata posta lì 4 minuti dopo. stackoverflow.com/questions/5518546/… Qualcuno migrerebbe e fonderebbe questa domanda (se possibile)?

— Giobbe

Sì, dopo averlo pubblicato qui, mi sono reso conto che probabilmente sarebbe meglio su Stackoverflow. Se qualcuno riesce a fonderlo, va bene per me.

— dbyrne,

Supponiamo di avere alcuni conti bancari:

(def accounts 
 [(ref 0) 
  (ref 10) 
  (ref 20) 
  (ref 30)])

E una funzione di "trasferimento" atomico:

(defn transfer [src-account dest-account amount]
  (dosync
    (alter dest-account + amount)
    (alter src-account - amount)))

Che funziona come segue:

(transfer (accounts 1) (accounts 0) 5)

(map deref accounts)
=> (5 5 20 30)

È quindi possibile comporre facilmente la funzione di trasferimento per creare una transazione di livello superiore, ad esempio il trasferimento da più account:

(defn transfer-from-all [src-accounts dest-account amount]
  (dosync
    (doseq [src src-accounts] 
      (transfer src dest-account amount))))

(transfer-from-all 
  [(accounts 0) (accounts 1) (accounts 2)] 
  (accounts 3) 
  5)

(map deref accounts)
=> (0 0 15 45)

Si noti che tutti i trasferimenti multipli sono avvenuti in una singola transazione combinata, ovvero è stato possibile "comporre" le transazioni più piccole.

Fare questo con i blocchi si complicherebbe molto rapidamente: supponendo che gli account debbano essere bloccati individualmente, allora dovresti fare qualcosa come stabilire un protocollo sull'ordine di acquisizione dei blocchi per evitare deadlock. È molto facile commettere un errore difficile da rilevare. STM ti salva da tutto questo dolore.

— mikera
fonte