multithreading - 改变 Clojure 的 ref 的线程越多，每个线程的重试率上升得越多？

Question

我有点担心这个。
想象一下最简单的版本控制方式，程序员只需从主存储库复制所有目录，如果主存储库仍然相同，则在更改文件后反向执行。如果已被其他人更改，则他们必须重试。

当程序员数量增加时，重试次数自然也会增加，但可能与程序员数量不成正比。
如 十 程序员工作，一个工作每人需要一个小时，才能完成所有工作十小时至少需要。
如果他们认真，大约 9 + 8 + 7 + ... 1 = 45 工时化为泡影。
在 百人程序员，大约 99 + 98 + ... 1 = 4950 工时化为泡影。

我试图计算重试次数并得到结果。

来源

(defn fib [n] 
   (if  (or (zero? n) (= n 1)) 
       1 
      (+  (fib (dec n) )  (fib (- n 2))))) 

(defn calc! [r counter-A counter-B counter-C n]
  (dosync
   (swap! counter-A inc)
   ;;(Thread/sleep n)
   (fib n)
   (swap! counter-B inc)
   (alter r inc)
   (swap! counter-C inc)))

(defn main [thread-num n]
  (let [r (ref 0)
        counter-A (atom 0)
        counter-B (atom 0)
        counter-C (atom 0)]
    (doall (pmap deref
              (for [_ (take thread-num (repeat nil))]
                (future (calc! r counter-A counter-B counter-C n)))))
    (println thread-num " Thread. @ref:" @r)
    (println "A:" @counter-A ", B:" @counter-B ", C:" @counter-C)))

CPU:2.93GHz 四核 Intel Core i7
结果

user> (time (main 10 25))
10  Thread. @ref: 10
A: 53 , B: 53 , C: 10
"Elapsed time: 94.412 msecs"
nil
user> (time (main 100 25))
100  Thread. @ref: 100
A: 545 , B: 545 , C: 100
"Elapsed time: 966.141 msecs"
nil
user> (time (main 1000 25))
1000  Thread. @ref: 1000
A: 5507 , B: 5507 , C: 1000
"Elapsed time: 9555.165 msecs"
nil

我将工作更改为 (Thread/sleep n) 而不是 (fib n) 并得到了类似的结果。

user> (time (main 10 20))
10  Thread. @ref: 10
A: 55 , B: 55 , C: 10
"Elapsed time: 220.616 msecs"
nil
user> (time (main 100 20))
100  Thread. @ref: 100
A: 689 , B: 689 , C: 117
"Elapsed time: 2013.729 msecs"
nil
user> (time (main 1000 20))
1000  Thread. @ref: 1000
A: 6911 , B: 6911 , C: 1127
"Elapsed time: 20243.214 msecs"
nil

在线程/ sleep 的情况下，我认为重试可能会比这个结果增加更多，因为 CPU 可用。
为什么不增加重试次数？

谢谢。

Answer 1

因为您实际上并没有产生 10、100 或 1000 个线程!创建 future does not always create a new thread .它使用 a thread pool behind the scenes它一直在排队工作(或 Runnable 是技术性的)。线程池是一个缓存线程池，它重用线程来运行作业。

所以在你的情况下，你实际上并没有产生 1000 个线程。如果您想查看实际重试，请获取低于 future 的级别- 创建自己的线程池并推送 Runnable进入它。