Il modo migliore per gestire un pool di risorse in Clojure

Question

Ho un endpoint di un servizio Web che utilizza una risorsa mutabile da una libreria Java. L'endpoint del servizio Web può ricevere più query contemporaneamente. (l'endpoint è implementato usando Ring/Compojure). La creazione di queste risorse è costosa, quindi la loro creazione per ogni chiamata al servizio Web è davvero inefficiente.

Quello che voglio fare è creare uno pool di quella risorsa che popolino all'avvio del servizio web. Quindi, ogni volta che viene chiamato l'endpoint, prende una risorsa dal pool, la utilizza per l'elaborazione, quindi la reinserisce nel pool e attende che si verifichi la prossima chiamata.

Mi chiedo quale sarebbe il modo migliore per farlo in Clojure? Esiste una libreria "pool" di Clojure che potrebbe aiutarmi?

Ho cercato ingenuamente di implementarlo utilizzando un vettore in un atomo in cui ogni elemento del vettore è quella risorsa. Tuttavia, ha rapidamente imparato che non potrebbe funzionare in questo modo.

Answer 1

questo si basa su un'idea Timothy Pratley s' di utilizzare arbitri:

(def pool (ref ['a 'b 'c])) 

(defn take' [pool] 
    (dosync 
    (let [[h & t] @pool] 
     (ref-set pool (vec t)) 
     h))) 

(defn put [pool x] 
    (dosync 
    (alter pool conj x) 
    nil)) 

(take' pool) ;; => 'a 
(put pool 'a) ;; => nil 
(take' pool) ;; => 'a 
(take' pool) ;; => 'b 
(take' pool) ;; => 'c 

Forse non è il modo migliore per attaccare questo. Ma mi piace la semplicità.

Answer 2

per implementare una piscina è necessario affrontare le preoccupazioni 2:

1. concorrenza. Utilizzare lockinghttps://clojuredocs.org/clojure.core/locking o un riferimento invece di un atomo. Le richieste possono essere simultanee, quindi è necessario fare attenzione che sia impossibile per due consumatori ricevere la stessa risorsa.

2. Liberare risorse. Prendi in considerazione l'uso di un modello come (con-open ...), cioè una macro che si espande in un try-finally in cui la risorsa viene rilasciata nuovamente al pool aperto quando lasci l'ambito del blocco.

Si potrebbe voler indicare uno stato di 'errore' così come 'disponibile' o 'in uso', in cui la risorsa può avere bisogno di essere rilasciato e ricreati.

Answer 3

Dai un'occhiata a questo kul/pool. Utilizza Apache Commons Pool. Spero sia utile

Answer 4

È inoltre possibile utilizzare un atomo:

(def pool (atom ['c 'b 'a])) 

(defn take' 
    [pool] 
    (loop [] 
    (let [p @pool] 
     (if (compare-and-set! pool p (pop p)) 
     (peek p) 
     (recur))))) 

(defn put 
    [pool x] 
    (swap! pool conj x) 
    nil) 

(take' pool) ;; => 'a 
(put pool 'a) ;; => nil 
(take' pool) ;; => 'a 
(take' pool) ;; => 'b 
(take' pool) ;; => 'c