操纵clojure中包含ref集合的原子

我有一个应用程序，应该在客户指定的预算内为他们预订航班。因此，我有客户数据和可用航班数据。然后我在Clojure中开发解决方案，如下所示

首先，我创建一个原子：

(def flights
   (atom []))

然后，我创建一个函数来初始化包含引用集合的原子的飞行。在这里，我传递航班数据，这些数据包含在这篇文章的后面

(defn initialize-flights [initial-flights]
   (reset! flights (map ref initial-flights)))

然后，我通过流程客户功能处理客户，如下所示。这就是它变得非常混乱的地方

(defn process-customers [customers]

(doseq [customer1 (partitionCustomerInput N-THREADS customers)]


  (doseq [customer2  customer1]

    (swap! flights
      (fn [flights_collection]
        (if-let [updated-flight (process-customer flights_collection customer2)]

          (assoc flights (:id updated-flight) updated-flight)
          flights_collection)))))


  (reset! finished-processing? true))

在流程客户内部，我将航班收集传递给流程客户（请注意，流程客户是流程客户的助手功能，它们不是相同的功能）。此时的航班集合是客户应在列表中搜索的航班参考流程的集合，如果客户符合列表中的航班条件，它将使用book功能编辑航班。我应该如何将航班收集传递给流程客户？实际上，流程客户不搜索航班参考，也不更改航班参考

下面是流程客户功能及其助手功能

(defn- process-customer [flights customer]
  "Try to book a flight from `flights` for `customer`, returning the updated
  flight if found, or nil if no suitable flight was found."
  (if-let [{:keys [flight price]} (find-flight flights customer)]
    (let [updated-flight (book flight price (:seats customer))]
      (log "Customer" (:id customer) "booked" (:seats customer)
        "seats on flight" (:id updated-flight) "at $" price " (< budget of $"
        (:budget customer) ").")
      updated-flight)
    (do
      (log "Customer" (:id customer) "did not find a flight.")
      nil)))


(defn filter-pricing-with-n-seats [pricing seats]
  "Get `pricing` for which there are at least `seats` empty seats available."
  (filter #(>= (second %) seats) pricing))

(defn lowest-available-price [flight seats]
  "Returns the lowest price in `flight` for which at least `seats` empty seats
  are available, or nil if none found."
  (-> (:pricing flight)                 ; [[price available taken]]
    (filter-pricing-with-n-seats seats)
    (sort-pricing)
    (first)                             ; [price available taken]
    (first)))                           ; price

(defn- find-flight [flights customer]
  "Find a flight in `flights` that is on the route and within the budget of
  `customer`. If a flight was found, returns {:flight flight :price price},
  else returns nil."
  (let [{:keys [_id from to seats budget]}
          customer
        flights-and-prices
          ; flights that are on the route and within budget, and their price
          (for [f flights
                :when (and (= (:from f) from) (= (:to f) to))
                :let [lowest-price (lowest-available-price f seats)]
                :when (and (some? lowest-price) (<= lowest-price budget))]
            {:flight f :price lowest-price})
        cheapest-flight-and-price
          (first (sort-by :price flights-and-prices))]
    cheapest-flight-and-price))

(defn- book [flight price seats]
  "Updates `flight` to book `seats` at `price`."
  (update flight :pricing
    (fn [pricing]
      (for [[p a t] pricing]
        (if (= p price)
          [p (- a seats) (+ t seats)]
          [p a t])))))



(def finished-processing?
  "Set to true once all customers have been processed, so that sales process
  can end."
  (atom false))

(defn partitionCustomerInput 
  [threads customers]
  (let [partitions (partition-all 
     (Math/ceil (/ (count customers) threads))  customers)]
        partitions))

以下是客户和航班收集

(def flights
      [{:id 0
        :from "BRU" :to "ATL"
        :carrier "Delta"
        :pricing [[600 150 0] ; price; # seats available at that price; # seats taken at that price
                  [650  50 0]
                  [700  50 0]
                  [800  50 0]]}
       {:id 1
        :from "BRU" :to "LON"
        :carrier "Brussels Airlines"
        :pricing [[300 150 0]
                  [350  50 0]
                  [370  20 0]
                  [380  30 0]]}
       {:id 2
        :from "BRU" :to "LON"
        :carrier "Brussels Airlines"
        :pricing [[250 100 0]
                  [300  50 0]]}
       {:id 3
        :from "BRU" :to "MAD"
        :carrier "Brussels Airlines"
        :pricing [[200 150 0]
                  [250  50 0]
                  [300 100 0]]}
       {:id 4
        :from "BRU" :to "MAD"
        :carrier "Iberia"
        :pricing [[250 150 0]
                  [300  50 0]]}])

(def customers
  [{:id  0 :from "BRU" :to "ATL" :seats 5 :budget 700}
   {:id  1 :from "BRU" :to "ATL" :seats 5 :budget 550}
   {:id  2 :from "BRU" :to "LON" :seats 6 :budget 270}
   {:id  3 :from "BRU" :to "ATL" :seats 4 :budget 600}
   {:id  4 :from "BRU" :to "LON" :seats 3 :budget 270}
   {:id  5 :from "BRU" :to "LON" :seats 9 :budget 250}
   {:id  6 :from "BRU" :to "MAD" :seats 5 :budget 200}
   {:id  7 :from "BRU" :to "MAD" :seats 9 :budget 150}
   {:id  8 :from "BRU" :to "LON" :seats 5 :budget 250}
   {:id  9 :from "BRU" :to "ATL" :seats 4 :budget 500}
   {:id 10 :from "BRU" :to "MAD" :seats 1 :budget 180}
   {:id 11 :from "BRU" :to "LON" :seats 2 :budget 320}
   {:id 12 :from "BRU" :to "ATL" :seats 3 :budget 850}
   {:id 13 :from "BRU" :to "ATL" :seats 4 :budget 200}])

---

另外，请注意，我想在这个实现中使用refs来更改航班，因为ref提供了对协调读写的支持，以原子方式更改航班。我的目标是为这个应用程序制定一个高度并行化的解决方案，冲突是不能容忍的。

我认为您需要一个ref，而不是顶层的atom。似乎您需要协调对单个航班的更改和对航班列表的更改。如果一个线程正在修改航班，而另一个线程将其从列表中删除，该怎么办？您的

过程客户

副作用必须在

（dosync）

内完成

就性能而言，这应该是可以的，因为如果您不在事务中修改flights ref列表，它将不会导致其他更改它的事务重试

另一个原因是，您违反了

交换的一条非常重要的规则。传递给
swap！的函数必须没有副作用，因为STM可以重试。修改ref是一种副作用，可能会导致难以理解的bug

所以我会这样做

(def flights 
  (ref [(ref {:id "flight-1"}) 
        (ref {:id "flight-2"})]))

;; Run a bunch of these in their own threads...
(doseq [customer partitioned-customers]
  (dosync (process-customer customer flights)))

然后，您可以使用
alter
、
comment
和
sure
对流程客户进行微调，以最大限度地提高并发性并减少重试次数

希望这对你有帮助，祝你好运
 当我看到一个包裹refs的原子时，我有点怀疑。您是否已经在不使用原子和引用的情况下实现了该算法？如果不是，我建议你先这样做。然后，我们可以看看如何使用多线程使其运行得更快。也许我们不需要这么多原子/参考？请查看此链接：。我在那里有两个实现，但它们没有加速。这就是为什么我选择了一个原子，它是飞行参考的集合：首先，它应该有可能改变整个飞行集合和单个飞行。我还希望我的REF具有精细的粒度，以确保在更新航班时减少冲突。如果不能在整个集合中使用atom，则意味着我无法对集合进行变异，而在整个集合中仅使用一个ref，并且删除atom将意味着大量的读写冲突。与您的一样，这对我们来说是一大堆需要消化的代码。另外，你的问题到底是什么？另外，ref用于“同时”修改两个对象，我在代码中看不到这一点。用原子代替，容易得多。也许你想让事情变得更平行，但你从哪里开始新的思路呢？我只能看到一个对
future
的调用，该调用适用于所有客户，而不是每个客户。如果我是你，我会先用一个更简单的算法处理期货、原子和参考值。
(def flights 
  (ref [(ref {:id "flight-1"}) 
        (ref {:id "flight-2"})]))

;; Run a bunch of these in their own threads...
(doseq [customer partitioned-customers]
  (dosync (process-customer customer flights)))