具有资格的生产者消费者

时间:2010-05-03 17:46:45

标签: clojure

我是clojure的新手并且正在尝试理解如何正确使用其并发功能,因此任何批评/建议都会受到赞赏。 所以我试图在clojure中编写一个小的测试程序,其工作原理如下:

  1. 有5个生产者和2个消费者
  2. 生产者等待一个随机时间,然后将一个数字推送到共享队列。
  3. 如果队列非空,消费者应该从队列中取出一个号码,然后再睡一小段时间以模拟工作
  4. 消费者应该在队列为空时阻止
  5. 生产者应该阻止队列中有超过4个项目,以防止它增长巨大
  6. 以上是我对上述每一步的计划:

    1. 生产者和消费者将是不真正关心他们的国家的代理人(只是零价值或其他东西);我只是使用代理发送一个“消费者”或“生产者”功能来做某个时间。然后共享队列将是(def队列(ref []))。也许这应该是一个原子呢?
    2. 在“生产者”代理函数中,简单地(Thread / sleep(rand-int 1000))然后(dosync(alter queue conj(rand-int 100)))推送到队列。
    3. 我正在考虑让消费者代理使用add-watcher监视队列中的更改。虽然不确定这一点,但是即使改变来自消费者拉动某些东西(可能使其变空),它也会唤醒消费者任何变化。也许在观察者功能中检查这一点就足够了。我看到的另一个问题是,如果所有消费者都很忙,那么当生产者向队列添加新内容时会发生什么?被监视的事件是否在某个消费者代理上排队或者是否消失了?
    4. 见上文
    5. 我真的不知道该怎么做。我听说clojure的seque可能有用,但我找不到足够的doc如何使用它,我的初步测试似乎不起作用(抱歉我的代码不再有了)

1 个答案:

答案 0 :(得分:24)

这是我的看法。我特别指出只使用Clojure数据结构来看看它是如何工作的。请注意,从Java工具箱中获取阻塞队列并在此处使用它是完全通常和惯用的。我想,代码很容易适应。 更新:我确实将其改编为java.util.concurrent.LinkedBlockingQueue,见下文。

clojure.lang.PersistentQueue

致电(pro-con)开始试运行;然后查看output的内容以查看是否发生了任何事情,并queue-lengths查看它们是否保持在给定范围内。

更新:为了解释为什么我觉得需要使用下面的ensure(我在IRC上被问过这个问题),这是为了防止写入歪斜(请参阅维基百科关于{的文章{3}}定义)。如果我用@queue代替(ensure queue),那么两个或更多生产者可以检查队列的长度,发现它小于4,然后在队列上放置其他项目并可能带来队列总长度超过4,打破了约束。同样,两个执行@queue的消费者可以接受相同的项目进行处理,然后从队列中弹出两个项目。 ensure可以防止这些情况发生。

(def go-on? (atom true))
(def queue (ref clojure.lang.PersistentQueue/EMPTY))
(def output (ref ()))
(def queue-lengths (ref ()))
(def *max-queue-length* 4)

(defn overseer
  ([] (overseer 20000))
  ([timeout]
     (Thread/sleep timeout)
     (swap! go-on? not)))

(defn queue-length-watch [_ _ _ new-queue-state]
  (dosync (alter queue-lengths conj (count new-queue-state))))

(add-watch queue :queue-length-watch queue-length-watch)

(defn producer [tag]
  (future
   (while @go-on?
     (if (dosync (let [l (count (ensure queue))]
                   (when (< l *max-queue-length*)
                     (alter queue conj tag)
                     true)))
       (Thread/sleep (rand-int 2000))))))

(defn consumer []
  (future
   (while @go-on?
     (Thread/sleep 100)       ; don't look at the queue too often
     (when-let [item (dosync (let [item (first (ensure queue))]
                               (alter queue pop)
                               item))]
       (Thread/sleep (rand-int 500))         ; do stuff
       (dosync (alter output conj item)))))) ; and let us know

(defn pro-con []
  (reset! go-on? true)
  (dorun (map #(%1 %2)
              (repeat 5 producer)
              (iterate inc 0)))
  (dorun (repeatedly 2 consumer))
  (overseer))

java.util.concurrent.LinkedBlockingQueue中

使用LinkedBlockingQueue编写的上述版本。请注意代码的大致轮廓基本相同,其中一些细节实际上稍微清晰一些。我从此版本中删除了queue-lengths,因为LBQ会为我们处理该约束。

(def go-on? (atom true))
(def *max-queue-length* 4)
(def queue (java.util.concurrent.LinkedBlockingQueue. *max-queue-length*))
(def output (ref ()))

(defn overseer
  ([] (overseer 20000))
  ([timeout]
     (Thread/sleep timeout)
     (swap! go-on? not)))

(defn producer [tag]
  (future
   (while @go-on?
     (.put queue tag)
     (Thread/sleep (rand-int 2000)))))

(defn consumer []
  (future
   (while @go-on?
     ;; I'm using .poll on the next line so as not to block
     ;; indefinitely if we're done; note that this has the
     ;; side effect that nulls = nils on the queue will not
     ;; be handled; there's a number of other ways to go about
     ;; this if this is a problem, see docs on LinkedBlockingQueue
     (when-let [item (.poll queue)]
       (Thread/sleep (rand-int 500)) ; do stuff
       (dosync (alter output conj item)))))) ; and let us know

(defn pro-con []
  (reset! go-on? true)
  (dorun (map #(%1 %2)
              (repeat 5 producer)
              (iterate inc 0)))
  (dorun (repeatedly 2 consumer))
  (overseer))