blocks|key|1513054|text|这(video，pdf)是关于用Java实现的无锁的哈希表。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1513055|搅局器:使用原子Compare-And-Swap+(CAS)操作，如果在Ruby语言中不可用，您可以用锁来模拟它们。我不确定这是否会比简单的锁保护哈希表有任何优势|1513056|entityMap|0|LINK|mutability|MUTABLE|url|http://video.google.com/videoplay?docid=2139967204534450862|1|http://www.azulsystems.com/events/javaone_2007/2007_LockFreeHash.pdf|2|http://en.wikipedia.org/wiki/Compare-and-swap^0|2|5|0|8|3|1|0|8|M|2|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|F|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|Q]]]]

this (<a href="http://video.google.com/videoplay?docid=2139967204534450862" rel="nofollow noreferrer">video</a>, <a href="http://www.azulsystems.com/events/javaone_2007/2007_LockFreeHash.pdf" rel="nofollow noreferrer">pdf</a>) is about lock-free hash table implemented in Java.

spoiler: uses atomic <a href="http://en.wikipedia.org/wiki/Compare-and-swap" rel="nofollow noreferrer">Compare-And-Swap (CAS)</a> operations, if not available in Ruby you could emulate them with locks. not sure if that would give any advantage over simple lock-guarded hashtables

blocks|key|1298366|text|没有经过测试，在优化读取方面做了一次天真的尝试。它假设在大多数情况下，值不会被锁定。如果是，紧密循环将尝试，直到它是。我将Thread.critical放在其中，以帮助确保在写入完成之前不会运行读线程。不确定是否需要关键部分，这真的取决于你的意思是读多重，所以一些基准测试是合适的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1298367|class+ConcurrentHash+<+Hash

++def+initialize(*args)
++++@semaphore+=+Mutex.new
++++super
++end

++def+[]=(k,v)
++++begin
++++++old_crit+=+Thread.critical
++++++Thread.critical+=+true+unless+old_crit
++++++@semaphore.synchronize+{+super+}
++++ensure
++++++Thread.critical+=+old_crit
++++end
++end

++def+[](k)
++++while(true)
++++++return+super+unless+@semaphore.locked?
++++end
++end

end|code-block|syntax|javascript|1298368|可能还有其他一些读取方法需要检查@信号量锁，我不知道是否所有其他方法都是在#[]中实现的。|1298369|entityMap^0|1P|F|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Not tested, and a naive stab at optimizing for reads. It assumes that most of the time, the value won't be locked. If it is, the tight loop will try until it is. I put <code>Thread.critical</code> in there to help ensure that the read threads won't be run until the write is completed. Not sure if the critical part is needed, it really depends on how read-heavy you mean, so some benchmarking is in order. 

<pre><code>class ConcurrentHash &lt; Hash

 def initialize(*args)
 @semaphore = Mutex.new
 super
 end

 def []=(k,v)
 begin
 old_crit = Thread.critical
 Thread.critical = true unless old_crit
 @semaphore.synchronize { super }
 ensure
 Thread.critical = old_crit
 end
 end

 def [](k)
 while(true)
 return super unless @semaphore.locked?
 end
 end

end
</code></pre>

There may be a few other read methods that would need to check the @semaphore lock, I don't know if everything else is implemented in terms of #[].

blocks|key|1513116|text|发布基础/朴素的解决方案，只是为了提升我的Stack+Overflow+cred：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1513117|require+'thread'

class+ConcurrentHash+<+Hash
++def+initialize
++++super
++++@mutex+=+Mutex.new
++end

++def+[](*args)
++++@mutex.synchronize+{+super+}
++end

++def+[]=(*args)
++++@mutex.synchronize+{+super+}
++end
end|code-block|syntax|javascript|1513118|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Posting base/naive solution, just to boost my Stack Overflow cred:

<pre><code>require 'thread'

class ConcurrentHash &lt; Hash
 def initialize
 super
 @mutex = Mutex.new
 end

 def [](*args)
 @mutex.synchronize { super }
 end

 def []=(*args)
 @mutex.synchronize { super }
 end
end
</code></pre>

blocks|key|1298427|text|耶胡达，我记得你提到依瓦尔的设置是原子的？那么简单的复制和交换如何？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1298428|require+'thread'

class+ConcurrentHash
++def+initialize
++++@reader,+@writer+=+{},+{}
++++@lock+=+Mutex.new
++end

++def+[](key)
++++@reader[key]
++end

++def+[]=(key,+value)
++++@lock.synchronize+{
++++++@writer[key]+=+value
++++++@reader,+@writer+=+@writer,+@reader
++++++@writer[key]+=+value
++++}
++end
end|code-block|syntax|javascript|1298429|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yehuda, I think you mentioned ivar setting was atomic? What about a simple copy and swap then?

<pre><code>require 'thread'

class ConcurrentHash
 def initialize
 @reader, @writer = {}, {}
 @lock = Mutex.new
 end

 def [](key)
 @reader[key]
 end

 def []=(key, value)
 @lock.synchronize {
 @writer[key] = value
 @reader, @writer = @writer, @reader
 @writer[key] = value
 }
 end
end
</code></pre>

blocks|key|1513228|text|由于您提到的Hash将是读取繁重的，因此拥有一个互斥锁同时锁定读取和写入将导致最有可能由读取赢得的竞争条件。如果你觉得没问题，那就忽略这个答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1513229|如果你想给写一个优先级，读写锁将会有帮助。下面的代码基于一些旧的操作系统类的c%2B%2B赋值，因此可能不是最好的质量，但给出了一个大致的概念。|1513230|require+'thread'

class+ReadWriteLock
++def+initialize
++++@critical_section+=+Mutex.new
++++@are_writers_finished+=+ConditionVariable.new
++++@are_readers_finished+=+ConditionVariable.new
++++@readers+=+0
++++@writers+=+0
++++@writer_locked+=+false
++end

++def+read
++++begin
++++++start_read
++++++yield
++++ensure
++++++end_read
++++end
++end

++def+start_read
++++@critical_section.lock
++++while+(@writers+!=+0+%7C%7C+@writer_locked)
++++++@are_writers_finished.wait(@critical_section)
++++end
++++@readers+%2B=+1
++++@critical_section.unlock
++end

++def+end_read
++++@critical_section.lock
++++if+(@readers+-=+1)+==+0
++++++@are_readers_finished.broadcast
++++end
++++@critical_section.unlock
++end

++def+write
++++begin
++++++start_write
++++++yield
++++ensure
++++++end_write
++++end
++end

++def+start_write
++++@critical_section.lock
++++@writers+%2B=+1
++++while+@readers+>+0
++++++@are_readers_finished.wait(@critical_section)
++++end
++++while+@writer_locked
++++++@are_writers_finished.wait(@critical_section)
++++end
++++@writers+-=+1
++++@writer_locked+=+true
++++@critical_section.unlock
++end

++def+end_write
++++@critical_section.lock
++++@writer_locked+=+false
++++@are_writers_finished.broadcast
++++@critical_section.unlock
++end
end|code-block|syntax|javascript|1513231|然后只需将[]=和[]包装在lock.write和lock.read中。可能会影响性能，但将保证写入将“通过”读取。这种方法的有用性取决于它实际的读取负担有多重。|1513232|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Since you mention the Hash would be read heavy, having one mutex locking both read and writes would result in race conditions that are most probably won by reads. If that's ok with you, then ignore the answer.

If you want to give writes a priority, an read-write lock would help. The following code is based on some old c++ assignment for Operating Systems class, so might not be best quality, but gives a general idea.

<pre><code>require 'thread'

class ReadWriteLock
 def initialize
 @critical_section = Mutex.new
 @are_writers_finished = ConditionVariable.new
 @are_readers_finished = ConditionVariable.new
 @readers = 0
 @writers = 0
 @writer_locked = false
 end

 def read
 begin
 start_read
 yield
 ensure
 end_read
 end
 end

 def start_read
 @critical_section.lock
 while (@writers != 0 || @writer_locked)
 @are_writers_finished.wait(@critical_section)
 end
 @readers += 1
 @critical_section.unlock
 end

 def end_read
 @critical_section.lock
 if (@readers -= 1) == 0
 @are_readers_finished.broadcast
 end
 @critical_section.unlock
 end

 def write
 begin
 start_write
 yield
 ensure
 end_write
 end
 end

 def start_write
 @critical_section.lock
 @writers += 1
 while @readers &gt; 0
 @are_readers_finished.wait(@critical_section)
 end
 while @writer_locked
 @are_writers_finished.wait(@critical_section)
 end
 @writers -= 1
 @writer_locked = true
 @critical_section.unlock
 end

 def end_write
 @critical_section.lock
 @writer_locked = false
 @are_writers_finished.broadcast
 @critical_section.unlock
 end
end
</code></pre>

Then just wrap []= and [] in lock.write and lock.read. Might have a performance impact, but will guarantee that writes will 'get through' the reads. Usefulness of this depends on how read heavy it actually is.

blocks|key|1298573|text|这是一个围绕Hash的包装类，它允许并发读取器，但会锁定所有其他类型的访问(包括迭代读取)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1298574|class+LockedHash
++def+initialize
++++@hash+=+Hash.new
++++@lock+=+ThreadAwareLock.new()
++++@reader_count+=+0
++end

++def+[](key)
++++@lock.lock_read
++++ret+=+@hash[key]
++++@lock.unlock_read
++++ret
++end

++def+[]=(key,+value)
++++@lock.lock_write
++++@hash[key]+=+value
++++@lock.unlock_write
++end

++def+method_missing(method_sym,+*arguments,+&block)
++++if+@hash.respond_to?+method_sym
++++++@lock.lock_block
++++++val+=+lambda{@hash.send(method_sym,*arguments,+&block)}.call
++++++@lock.unlock_block
++++++return+val
++++end
++++super
++end
end|code-block|syntax|javascript|1298575|下面是它使用的锁定代码：|1298576|class+RWLock
++def+initialize
++++@outer+=+Mutex.new
++++@inner+=+Mutex.new
++++@reader_count+=+0
++end
++def+lock_read
++++@outer.synchronize{@inner.synchronize{@reader_count+%2B=+1}}
++end
++def+unlock_read
++++@inner.synchronize{@reader_count+-=+1}
++end
++def+lock_write
++++@outer.lock
++++while+@reader_count+>+0+;end
++end
++def+unlock_write
++++@outer.unlock
++end
end

class+ThreadAwareLock+<+RWLock
++def+initialize
++++@owner+=+nil
++++super
++end
++def+lock_block
++++lock_write
++++@owner+=+Thread.current.object_id
++end
++def+unlock_block
++++@owner+=+nil
++++unlock_write
++end
++def+lock_read
++++super+unless+my_block?
++end
++def+unlock_read
++++super+unless+my_block?
++end
++def+lock_write
++++super+unless+my_block?
++end
++def+unlock_write
++++super+unless+my_block?
++end
++def+my_block?
++++@owner+==+Thread.current.object_id
++end
end|1298577|线程感知锁允许您锁定类一次，然后调用通常会锁定的方法，并使它们不锁定。您需要这样做，因为您在某些方法中使用了块，而这些块可以调用对象上的锁定方法，并且您不希望出现死锁或双重锁定错误。你可以使用一个计数锁来代替它。|1298578|下面是实现存储桶级读写锁的一个尝试：|1298579|class+SafeBucket
++def+initialize
++++@lock+=+RWLock.new()
++++@value_pairs+=+[]
++end

++def+get(key)
++++@lock.lock_read
++++pair+=+@value_pairs.select{%7Cp%7C+p[0]+==+key}
++++unless+pair+&&+pair.size+>+0
++++++@lock.unlock_read
++++++return+nil
++++end
++++ret+=+pair[0][1]
++++@lock.unlock_read
++++ret
++end

++def+set(key,+value)
++++@lock.lock_write
++++pair+=+@value_pairs.select{%7Cp%7C+p[0]+==+key}
++++if+pair+&&+pair.size+>+0
++++++pair[0][1]+=+value
++++++@lock.unlock_write
++++++return
++++end
++++@value_pairs.push+[key,+value]
++++@lock.unlock_write
++++value
++end

++def+each
++++@value_pairs.each{%7Cp%7C+yield+p[0],p[1]}
++end

end

class+MikeConcurrentHash
++def+initialize
++++@buckets+=+[]
++++100.times+{@buckets.push+SafeBucket.new}
++end

++def+[](key)
++++bucket(key).get(key)
++end

++def+[]=(key,+value)
++++bucket(key).set(key,+value)
++end

++def+each
++++@buckets.each{%7Cb%7C+b.each{%7Ckey,+value%7C+yield+key,+value}}
++end

++def+bucket(key)
++++@buckets[key.hash+%25+100]
++end
end|1298580|我停止了这方面的工作，因为它太慢了，所以each方法是不安全的(允许在迭代期间被其他线程改变)，并且它不支持大多数散列方法。|1298581|下面是针对并发散列的测试工具：|1298582|require+'thread'
class+HashHarness
++Keys+=+[:a,+:basic,+:test,+:harness,+:for,+:concurrent,+:testing,+:of,+:hashes,
++++++++++:that,+:tries,+:to,+:provide,+:a,+:framework,+:for,+:designing,+:a,+:good,+:ConcurrentHash,
++++++++++:for,+:all,+:ruby,+:implementations]

++def+self.go
++++h+=+new
++++r+=+h.writiness_range(20,+10000,+0,+0)
++++r.each{%7Ck,+v%7C+p+k+%2B+'+'+%2B+v.map{%7Cp%7C+p[1]}.join('+')}
++++return
++end
++def+initialize(classes+=+[MikeConcurrentHash,+JoshConcurrentHash,+JoshConcurrentHash2,+PaulConcurrentHash,+LockedHash,+Hash])
++++@classes+=+classes
++end
++def+writiness_range(basic_threads,+ops,+each_threads,+loops)
++++result+=+{}
++++@classes.each+do+%7Chash_class%7C
++++++res+=+[]
++++++0.upto+10+do+%7Ci%7C
++++++++writiness+=+i.to_f+/+10
++++++++res.push+[writiness,test_one(hash_class,+basic_threads,+ops,+each_threads,+loops,+writiness)]
++++++end
++++++result[hash_class.name]+=+res
++++end
++++result
++end
++def+test_one(hash_class,+basic_threads,+ops,+each_threads,+loops,+writiness)
++++time+=+Time.now
++++threads+=+[]
++++hash+=+hash_class.new
++++populate_hash(hash)
++++begin
++++basic_threads.times+do
++++++threads.push+Thread.new{run_basic_test(hash,+writiness,+ops)}
++++end
++++each_threads.times+do
++++++threads.push+Thread.new{run_each_test(hash,+writiness,+loops)}
++++end
++++threads.each{%7Ct%7C+t.join}
++++rescue+ThreadError+=>+e
++++++p+[e.message,+hash_class.name,+basic_threads,+ops,+each_threads,+loops,+writiness].join('+')
++++++return+-1
++++end
++++p+[hash_class.name,+basic_threads,+ops,+each_threads,+loops,+writiness,+Time.now+-+time].join('+')
++++return+Time.now+-+time
++end
++def+run_basic_test(hash,+writiness,+ops)
++++ops.times+do
++++++rand+<+writiness+?+hash[choose_key]=+rand+:+hash[choose_key]
++++end
++end
++def+run_each_test(hash,+writiness,+loops)
++++loops.times+do
++++++hash.each+do+%7Ck,+v%7C
++++++++if+rand+<+writiness
++++++++++each_write_work(hash,+k,+v)
++++++++else
++++++++++each_read_work(k,+v)
++++++++end
++++++end
++++end
++end
++def+each_write_work(hash,+key,+value)
++++hash[key]+=+rand
++end
++def+each_read_work(key,+value)
++++key.to_s+%2B+":+"+%2B+value.to_s
++end
++def+choose_key
++++Keys[rand(Keys.size)]
++end
++def+populate_hash(hash)
++++Keys.each{%7Ckey%7C+hash[key]=rand}++
++end
end|1298583|数字:+Jruby|1298584|Writiness++++++0.0+++0.1+++0.2+++0.3+++0.4+++0.5+++0.6+++0.7+++0.8+++0.9+++1.0
ConcurrentHash+2.098+3.179+2.971+3.083+2.731+2.941+2.564+2.480+2.369+1.862+1.881
LockedHash+++++1.873+1.896+2.085+2.058+2.001+2.055+1.904+1.921+1.873+1.841+1.630
Hash+++++++++++0.530+0.672+0.685+0.822+0.719+0.877+0.901+0.931+0.942+0.950+1.001|1298585|和MRI|1298586|Writiness++++++0.0++++0.1++++0.2++++0.3++++0.4++++0.5++++0.6++++0.7++++0.8++++0.9++++1.0
ConcurrentHash++9.214++9.913++9.064+10.112+10.240+10.574+10.566+11.027+11.323+11.837+13.036
LockedHash+++++19.593+17.712+16.998+17.045+16.687+16.609+16.647+15.307+14.464+13.931+14.146
Hash++++++++++++0.535++0.537++0.534++0.599++0.594++0.676++0.635++0.650++0.654++0.661++0.692|1298587|核磁共振仪的数据相当惊人。锁定核磁共振真的很糟糕。|1298588|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1K|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|1M|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

This is a wrapper class around Hash that allows concurrent readers, but locks things down for all other types of access (including iterated reads).

<pre><code>class LockedHash
 def initialize
 @hash = Hash.new
 @lock = ThreadAwareLock.new()
 @reader_count = 0
 end

 def [](key)
 @lock.lock_read
 ret = @hash[key]
 @lock.unlock_read
 ret
 end

 def []=(key, value)
 @lock.lock_write
 @hash[key] = value
 @lock.unlock_write
 end

 def method_missing(method_sym, *arguments, &amp;block)
 if @hash.respond_to? method_sym
 @lock.lock_block
 val = lambda{@hash.send(method_sym,*arguments, &amp;block)}.call
 @lock.unlock_block
 return val
 end
 super
 end
end
</code></pre>

Here is the locking code it uses:

<pre><code>class RWLock
 def initialize
 @outer = Mutex.new
 @inner = Mutex.new
 @reader_count = 0
 end
 def lock_read
 @outer.synchronize{@inner.synchronize{@reader_count += 1}}
 end
 def unlock_read
 @inner.synchronize{@reader_count -= 1}
 end
 def lock_write
 @outer.lock
 while @reader_count &gt; 0 ;end
 end
 def unlock_write
 @outer.unlock
 end
end

class ThreadAwareLock &lt; RWLock
 def initialize
 @owner = nil
 super
 end
 def lock_block
 lock_write
 @owner = Thread.current.object_id
 end
 def unlock_block
 @owner = nil
 unlock_write
 end
 def lock_read
 super unless my_block?
 end
 def unlock_read
 super unless my_block?
 end
 def lock_write
 super unless my_block?
 end
 def unlock_write
 super unless my_block?
 end
 def my_block?
 @owner == Thread.current.object_id
 end
end
</code></pre>

The thread-aware lock is to allow you to lock the class once, and then call methods that would normally lock, and have them not lock. You need this because you yield into blocks inside some methods, and those blocks can call locking methods on the object, and you don't want a deadlock or a double-lock error. You could use a counting lock instead for this.

Here's an attempt to implement bucket-level read-write locks:

<pre><code>class SafeBucket
 def initialize
 @lock = RWLock.new()
 @value_pairs = []
 end

 def get(key)
 @lock.lock_read
 pair = @value_pairs.select{|p| p[0] == key}
 unless pair &amp;&amp; pair.size &gt; 0
 @lock.unlock_read
 return nil
 end
 ret = pair[0][1]
 @lock.unlock_read
 ret
 end

 def set(key, value)
 @lock.lock_write
 pair = @value_pairs.select{|p| p[0] == key}
 if pair &amp;&amp; pair.size &gt; 0
 pair[0][1] = value
 @lock.unlock_write
 return
 end
 @value_pairs.push [key, value]
 @lock.unlock_write
 value
 end

 def each
 @value_pairs.each{|p| yield p[0],p[1]}
 end

end

class MikeConcurrentHash
 def initialize
 @buckets = []
 100.times {@buckets.push SafeBucket.new}
 end

 def [](key)
 bucket(key).get(key)
 end

 def []=(key, value)
 bucket(key).set(key, value)
 end

 def each
 @buckets.each{|b| b.each{|key, value| yield key, value}}
 end

 def bucket(key)
 @buckets[key.hash % 100]
 end
end
</code></pre>

I stopped working on this because it's too slow, so the each method is unsafe (allows mutations by other threads during an iteration) and it doesn't support most hash methods.

And here's a test harness for concurrent hashes:

<pre><code>require 'thread'
class HashHarness
 Keys = [:a, :basic, :test, :harness, :for, :concurrent, :testing, :of, :hashes,
 :that, :tries, :to, :provide, :a, :framework, :for, :designing, :a, :good, :ConcurrentHash,
 :for, :all, :ruby, :implementations]

 def self.go
 h = new
 r = h.writiness_range(20, 10000, 0, 0)
 r.each{|k, v| p k + ' ' + v.map{|p| p[1]}.join(' ')}
 return
 end
 def initialize(classes = [MikeConcurrentHash, JoshConcurrentHash, JoshConcurrentHash2, PaulConcurrentHash, LockedHash, Hash])
 @classes = classes
 end
 def writiness_range(basic_threads, ops, each_threads, loops)
 result = {}
 @classes.each do |hash_class|
 res = []
 0.upto 10 do |i|
 writiness = i.to_f / 10
 res.push [writiness,test_one(hash_class, basic_threads, ops, each_threads, loops, writiness)]
 end
 result[hash_class.name] = res
 end
 result
 end
 def test_one(hash_class, basic_threads, ops, each_threads, loops, writiness)
 time = Time.now
 threads = []
 hash = hash_class.new
 populate_hash(hash)
 begin
 basic_threads.times do
 threads.push Thread.new{run_basic_test(hash, writiness, ops)}
 end
 each_threads.times do
 threads.push Thread.new{run_each_test(hash, writiness, loops)}
 end
 threads.each{|t| t.join}
 rescue ThreadError =&gt; e
 p [e.message, hash_class.name, basic_threads, ops, each_threads, loops, writiness].join(' ')
 return -1
 end
 p [hash_class.name, basic_threads, ops, each_threads, loops, writiness, Time.now - time].join(' ')
 return Time.now - time
 end
 def run_basic_test(hash, writiness, ops)
 ops.times do
 rand &lt; writiness ? hash[choose_key]= rand : hash[choose_key]
 end
 end
 def run_each_test(hash, writiness, loops)
 loops.times do
 hash.each do |k, v|
 if rand &lt; writiness
 each_write_work(hash, k, v)
 else
 each_read_work(k, v)
 end
 end
 end
 end
 def each_write_work(hash, key, value)
 hash[key] = rand
 end
 def each_read_work(key, value)
 key.to_s + ": " + value.to_s
 end
 def choose_key
 Keys[rand(Keys.size)]
 end
 def populate_hash(hash)
 Keys.each{|key| hash[key]=rand} 
 end
end
</code></pre>

Numbers:
Jruby

<pre><code>Writiness 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
ConcurrentHash 2.098 3.179 2.971 3.083 2.731 2.941 2.564 2.480 2.369 1.862 1.881
LockedHash 1.873 1.896 2.085 2.058 2.001 2.055 1.904 1.921 1.873 1.841 1.630
Hash 0.530 0.672 0.685 0.822 0.719 0.877 0.901 0.931 0.942 0.950 1.001
</code></pre>

And MRI

<pre><code>Writiness 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
ConcurrentHash 9.214 9.913 9.064 10.112 10.240 10.574 10.566 11.027 11.323 11.837 13.036
LockedHash 19.593 17.712 16.998 17.045 16.687 16.609 16.647 15.307 14.464 13.931 14.146
Hash 0.535 0.537 0.534 0.599 0.594 0.676 0.635 0.650 0.654 0.661 0.692
</code></pre>

MRI numbers are pretty striking. Locking in MRI really sucks.

blocks|key|1298706|text|好了，现在您已经指定了“threadsafe”的实际含义，下面是两个可能的实现。下面的代码将永远在MRI和JRuby中运行。无锁实现遵循最终的一致性模型，其中每个线程使用自己的散列视图，如果主线程处于变化中。需要一些小技巧来确保将所有信息存储在线程中不会泄漏内存，但这是经过处理和测试的-运行此代码时，进程大小不会增长。这两个实现都需要更多的工作才能“完成”，这意味着删除、更新等都需要一些思考，但下面两个概念中的任何一个都可以满足您的需求。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1298707|对于阅读这个帖子的人来说，认识到整个问题是JRuby独有的是非常重要的-在磁共振成像中，内置的哈希就足够了。|1298708|module+Cash
++def+Cash.new(*args,+&block)
++++env+=+ENV['CASH_IMPL']
++++impl+=+env+?+Cash.const_get(env)+:+LocklessImpl
++++klass+=+defined?(JRUBY_VERSION)+?+impl+:+::Hash
++++klass.new(*args)
++end

++class+LocklessImpl
++++def+initialize
++++++@hash+=+{}
++++end

++++def+thread_hash
++++++thread+=+Thread.current
++++++thread[:cash]+%7C%7C=+{}
++++++hash+=+thread[:cash][thread_key]
++++++if+hash
++++++++hash
++++++else
++++++++hash+=+thread[:cash][thread_key]+=+{}
++++++++ObjectSpace.define_finalizer(self){+thread[:cash].delete(thread_key)+}
++++++++hash
++++++end
++++end

++++def+thread_key
++++++[Thread.current.object_id,+object_id]
++++end

++++def+[]=(key,+val)
++++++time+=+Time.now.to_f
++++++tuple+=+[time,+val]
++++++@hash[key]+=+tuple
++++++thread_hash[key]+=+tuple
++++++val
++++end

++++def+[](key)
++++#+check+the+master+value
++++#
++++++val+=+@hash[key]

++++#+someone+else+is+either+writing+the+key+or+it+has+never+been+set.++we
++++#+need+to+invalidate+our+own+copy+in+either+case
++++#
++++++if+val.nil?
++++++++thread_val+=+thread_hash.delete(key)
++++++++return(thread_val+?+thread_val.last+:+nil)
++++++end

++++#+check+our+own+thread+local+value
++++#
++++++thread_val+=+thread_hash[key]

++++#+in+this+case+someone+else+has+written+a+value+that+we+have+never+seen+so
++++#+simply+return+it
++++#
++++++if+thread_val.nil?
++++++++return(val.last)
++++++end

++++#+in+this+case+there+is+a+master+*and*+a+thread+local+value,+if+the+master
++++#+is+newer+juke+our+own+cached+copy
++++#
++++++if+val.first+>+thread_val.first
++++++++thread_hash.delete(key)
++++++++return+val.last
++++++else
++++++++return+thread_val.last
++++++end
++++end
++end

++class+LockingImpl+<+::Hash
++++require+'sync'

++++def+initialize(*args,+&block)
++++++super
++++ensure
++++++extend+Sync_m
++++end

++++def+sync(*args,+&block)
++++++sync_synchronize(*args,+&block)
++++end

++++def+[](key)
++++++sync(:SH){+super+}
++++end

++++def+[]=(key,+val)
++++++sync(:EX){+super+}
++++end
++end
end



if+$0+==+__FILE__
++iteration+=+0

++loop+do
++++n+=+42
++++hash+=+Cash.new

++++threads+=
++++++Array.new(10)+{
++++++++Thread.new+do
++++++++++Thread.current.abort_on_exception+=+true
++++++++++n.times+do+%7Ckey%7C
++++++++++++hash[key]+=+key
++++++++++++raise+"#{+key+}=nil"+if+hash[key].nil?
++++++++++end
++++++++end
++++++}

++++threads.map{%7Cthread%7C+thread.join}

++++puts+"THREADSAFE:+#{+iteration+%2B=+1+}"
++end
end|code-block|syntax|javascript|1298709|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Okay, now that you specified the actually meaning of 'threadsafe', here are two potential implementations. The following code will run forever in MRI and JRuby. The lockless implementation follows an eventual consistency model where each thread uses it's own view of the hash if the master is in flux. There is a little trickery required to make sure storing all the information in the thread doesn't leak memory, but that is handled and tested ― process size does not grow running this code. Both implementations would need more work to be 'complete', meaning delete, update, etc. would need some thinking, but either of the two concepts below will meet your requirements.

It's very important for people reading this thread to realize the whole issue is exclusive to JRuby ― in MRI the built-in Hash is sufficient.

<pre><code>module Cash
 def Cash.new(*args, &amp;block)
 env = ENV['CASH_IMPL']
 impl = env ? Cash.const_get(env) : LocklessImpl
 klass = defined?(JRUBY_VERSION) ? impl : ::Hash
 klass.new(*args)
 end

 class LocklessImpl
 def initialize
 @hash = {}
 end

 def thread_hash
 thread = Thread.current
 thread[:cash] ||= {}
 hash = thread[:cash][thread_key]
 if hash
 hash
 else
 hash = thread[:cash][thread_key] = {}
 ObjectSpace.define_finalizer(self){ thread[:cash].delete(thread_key) }
 hash
 end
 end

 def thread_key
 [Thread.current.object_id, object_id]
 end

 def []=(key, val)
 time = Time.now.to_f
 tuple = [time, val]
 @hash[key] = tuple
 thread_hash[key] = tuple
 val
 end

 def [](key)
 # check the master value
 #
 val = @hash[key]

 # someone else is either writing the key or it has never been set. we
 # need to invalidate our own copy in either case
 #
 if val.nil?
 thread_val = thread_hash.delete(key)
 return(thread_val ? thread_val.last : nil)
 end

 # check our own thread local value
 #
 thread_val = thread_hash[key]

 # in this case someone else has written a value that we have never seen so
 # simply return it
 #
 if thread_val.nil?
 return(val.last)
 end

 # in this case there is a master *and* a thread local value, if the master
 # is newer juke our own cached copy
 #
 if val.first &gt; thread_val.first
 thread_hash.delete(key)
 return val.last
 else
 return thread_val.last
 end
 end
 end

 class LockingImpl &lt; ::Hash
 require 'sync'

 def initialize(*args, &amp;block)
 super
 ensure
 extend Sync_m
 end

 def sync(*args, &amp;block)
 sync_synchronize(*args, &amp;block)
 end

 def [](key)
 sync(:SH){ super }
 end

 def []=(key, val)
 sync(:EX){ super }
 end
 end
end



if $0 == __FILE__
 iteration = 0

 loop do
 n = 42
 hash = Cash.new

 threads =
 Array.new(10) {
 Thread.new do
 Thread.current.abort_on_exception = true
 n.times do |key|
 hash[key] = key
 raise "#{ key }=nil" if hash[key].nil?
 end
 end
 }

 threads.map{|thread| thread.join}

 puts "THREADSAFE: #{ iteration += 1 }"
 end
end
</code></pre>

blocks|key|1513559|text|不幸的是，我不能在Michael+Sofaer介绍的地方添加评论:类RWLock和带有@reader_count的类LockedHash等等(还没有足够的因果报应)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1513560|这种解决方案不起作用。它给出一个错误:在‘unlock’中:试图解锁未锁定的互斥锁(ThreadError)|1513561|由于逻辑错误:当需要解锁时，解锁会额外发生1次(因为缺少检查my_block?()。相反，它会解锁它，即使解锁不是必须的(“就是我的块”)，因此在已经解锁的静音上第二次解锁会引发异常。(我将在本文末尾粘贴有关如何重现此错误的完整代码)。|1513562|Michael还提到“each方法是不安全的(允许在迭代期间被其他线程改变)”，这对我来说很重要，所以我最终得到了这个简化的解决方案，它适用于我所有的用例，当从不同的线程调用任何hash方法时，它简单地锁定互斥(来自拥有锁的同一线程的调用不会被阻塞，以避免死锁)：|1513563|#
#+This+TrulyThreadSafeHash+works!
#
#+Note+if+one+thread+iterating+the+hash+by+#each+method
#+then+the+hash+will+be+locked+for+all+other+threads+(they+will+not+be+
#+able+to+even+read+from+it)
#
class+TrulyThreadSafeHash
++def+initialize
++++@mutex+=+Mutex.new
++++@hash+=+Hash.new
++end

++def+method_missing(method_sym,+*arguments,+&block)

++++if+!@mutex.owned?++#+Returns+true+if+this+lock+is+currently+held+by+current+thread
++++++++#+We're+trying+to+lock+only+if+mutex+is+not+owned+by+the+current+thread+(is+not+locked+or+is+locked+by+some+other+thread).
++++++++#+Following+call+will+be+blocking+if+mutex+locked+by+other+thread:
++++++++@mutex.synchronize{
++++++++++++return+lambda{@hash.send(method_sym,*arguments,+&block)}.call
++++++++}
++++end

++++#+We+already+own+the+lock+(from+current+thread+perspective).
++++#+We+don't+even+check+if+@hash.respond_to?(method_sym),+let's+make+Hash
++++#+respond+properly+on+all+calls+(including+bad+calls+(example:+wrong+method+names))
++++lambda{@hash.send(method_sym,*arguments,+&block)}.call
++end

++#+since+we're+tyring+to+mimic+Hash+we'll+pretend+to+respond+as+Hash+would
++def+self.respond_to?(method_sym,+include_private+=+false)
++++Hash.respond_to(method_sym,+include_private)
++end

++#+override+Object's+to_s+because+our+method_missing+won't+be+called+for+to_s
++def+to_s(*arguments)
++++++@mutex.synchronize{
++++++++return+@hash.to_s
++++++}
++end

++#+And+for+those,+who+want+to+run+extra+mile:
++#+to+make+our+class+json-friendly+we+shoud+require+'json'+and+uncomment+this:
++#def+to_json(*options)
++#++++@mutex.synchronize{
++#++++++++return+@hash.to_json(*options)
++#++++}
++#end

end|code-block|syntax|javascript|1513564|现在是演示/重现Michael+Sofaer解决方案中的双重解锁错误的完整示例：|1513565|#!/usr/bin/env+ruby

#+=======+unchanged+copy-paste+part+from+Michael+Sofaer+answer+(begin)+=======

class+LockedHash
++def+initialize
++++@hash+=+Hash.new
++++@lock+=+ThreadAwareLock.new()
++++@reader_count+=+0
++end

++def+[](key)
++++@lock.lock_read
++++ret+=+@hash[key]
++++@lock.unlock_read
++++ret
++end

++def+[]=(key,+value)
++++@lock.lock_write
++++@hash[key]+=+value
++++@lock.unlock_write
++end

++def+method_missing(method_sym,+*arguments,+&block)
++++if+@hash.respond_to?+method_sym
++++++@lock.lock_block
++++++val+=+lambda{@hash.send(method_sym,*arguments,+&block)}.call
++++++@lock.unlock_block
++++++return+val
++++end
++++super
++end
end



class+RWLock
++def+initialize
++++@outer+=+Mutex.new
++++@inner+=+Mutex.new
++++@reader_count+=+0
++end
++def+lock_read
++++@outer.synchronize{@inner.synchronize{@reader_count+%2B=+1}}
++end
++def+unlock_read
++++@inner.synchronize{@reader_count+-=+1}
++end
++def+lock_write
++++@outer.lock
++++while+@reader_count+>+0+;end
++end
++def+unlock_write
++++@outer.unlock
++end
end

class+ThreadAwareLock+<+RWLock
++def+initialize
++++@owner+=+nil
++++super
++end
++def+lock_block
++++lock_write
++++@owner+=+Thread.current.object_id
++end
++def+unlock_block
++++@owner+=+nil
++++unlock_write
++end
++def+lock_read
++++super+unless+my_block?
++end
++def+unlock_read
++++super+unless+my_block?
++end
++def+lock_write
++++super+unless+my_block?
++end
++def+unlock_write
++++super+unless+my_block?
++end
++def+my_block?
++++@owner+==+Thread.current.object_id
++end
end

#+=======+unchanged+copy-paste+part+from+Michael+Sofaer+answer+(end)+=======


#+global+hash+object,+which+will+be+'shared'+across+threads
$h+=+LockedHash.new

#+hash_reader+is+just+iterating+through+the+'shared'+hash+$h
#+and+prints+specified+delimeter+(capitalized+when+last+hash+item+read)
def+hash_reader(delim)
++++loop{
++++++++count+=+0
++++++++$h.each{
++++++++++++count+%2B=+1
++++++++++++if+count+!=+$h.size
++++++++++++++++$stderr.print+delim
++++++++++++else
++++++++++++++++$stderr.puts+delim.upcase
++++++++++++end
++++++++}
++++}
end

#+fill+hash+with+10+items
10.times{%7Ci%7C
++++$h[i]+=+i
}

#+create+a+thread+which+will+read+$h+hash
t1+=+Thread.new(){
++++hash_reader("o")
}

t1.join++#+will+never+happen,+but+for+completeness|1513566|，这会给出以下错误：|1513567|./LockedHash_fails_to_unlock.rb
oooooooooO
./LockedHash_fails_to_unlock.rb:55:in+`unlock':+Attempt+to+unlock+a+mutex+which+is+not+locked+(ThreadError)
++++++++from+./LockedHash_fails_to_unlock.rb:55:in+`unlock_write'
++++++++from+./LockedHash_fails_to_unlock.rb:82:in+`unlock_write'
++++++++from+./LockedHash_fails_to_unlock.rb:70:in+`unlock_block'
++++++++from+./LockedHash_fails_to_unlock.rb:29:in+`method_missing'
++++++++from+./LockedHash_fails_to_unlock.rb:100:in+`block+in+hash_reader'
++++++++from+./LockedHash_fails_to_unlock.rb:98:in+`loop'
++++++++from+./LockedHash_fails_to_unlock.rb:98:in+`hash_reader'
++++++++from+./LockedHash_fails_to_unlock.rb:119:in+`block+in+<main>'|1513568|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Unfortunately I can't add a comment to Michael Sofaer answer where he introduces: class RWLock and class LockedHash with @reader_count etc. (don't have enough karma yet)

That solution does not work. It gives an error:
in `unlock': Attempt to unlock a mutex which is not locked (ThreadError)

Due to the logical bug: when it's time to unlock things then unlock happens 1 extra time (because of missing check my_block?(). Instead it unblocks it even if unblocking was not necessary "is my block") and so 2nd unlock on already unlocked mutes raises an exception. (I'll paste full code on how to reproduce this error at the end of this post).

Also Michael mentioned "the each method is unsafe (allows mutations by other threads during an iteration)" which was critical for me, so I end up with this simplified solution which works for all my use cases and it simply locks mutex on any call to any hash method when called from different thread (calls from the same thread, which owns the lock are not blocking to avoid deadlocks):

<pre><code>#
# This TrulyThreadSafeHash works!
#
# Note if one thread iterating the hash by #each method
# then the hash will be locked for all other threads (they will not be 
# able to even read from it)
#
class TrulyThreadSafeHash
 def initialize
 @mutex = Mutex.new
 @hash = Hash.new
 end

 def method_missing(method_sym, *arguments, &amp;block)

 if !@mutex.owned? # Returns true if this lock is currently held by current thread
 # We're trying to lock only if mutex is not owned by the current thread (is not locked or is locked by some other thread).
 # Following call will be blocking if mutex locked by other thread:
 @mutex.synchronize{
 return lambda{@hash.send(method_sym,*arguments, &amp;block)}.call
 }
 end

 # We already own the lock (from current thread perspective).
 # We don't even check if @hash.respond_to?(method_sym), let's make Hash
 # respond properly on all calls (including bad calls (example: wrong method names))
 lambda{@hash.send(method_sym,*arguments, &amp;block)}.call
 end

 # since we're tyring to mimic Hash we'll pretend to respond as Hash would
 def self.respond_to?(method_sym, include_private = false)
 Hash.respond_to(method_sym, include_private)
 end

 # override Object's to_s because our method_missing won't be called for to_s
 def to_s(*arguments)
 @mutex.synchronize{
 return @hash.to_s
 }
 end

 # And for those, who want to run extra mile:
 # to make our class json-friendly we shoud require 'json' and uncomment this:
 #def to_json(*options)
 # @mutex.synchronize{
 # return @hash.to_json(*options)
 # }
 #end

end
</code></pre>

And now the full example to demonstrate / reproduce the error of double unlocking in Michael Sofaer's solution:

<pre><code>#!/usr/bin/env ruby

# ======= unchanged copy-paste part from Michael Sofaer answer (begin) =======

class LockedHash
 def initialize
 @hash = Hash.new
 @lock = ThreadAwareLock.new()
 @reader_count = 0
 end

 def [](key)
 @lock.lock_read
 ret = @hash[key]
 @lock.unlock_read
 ret
 end

 def []=(key, value)
 @lock.lock_write
 @hash[key] = value
 @lock.unlock_write
 end

 def method_missing(method_sym, *arguments, &amp;block)
 if @hash.respond_to? method_sym
 @lock.lock_block
 val = lambda{@hash.send(method_sym,*arguments, &amp;block)}.call
 @lock.unlock_block
 return val
 end
 super
 end
end



class RWLock
 def initialize
 @outer = Mutex.new
 @inner = Mutex.new
 @reader_count = 0
 end
 def lock_read
 @outer.synchronize{@inner.synchronize{@reader_count += 1}}
 end
 def unlock_read
 @inner.synchronize{@reader_count -= 1}
 end
 def lock_write
 @outer.lock
 while @reader_count &gt; 0 ;end
 end
 def unlock_write
 @outer.unlock
 end
end

class ThreadAwareLock &lt; RWLock
 def initialize
 @owner = nil
 super
 end
 def lock_block
 lock_write
 @owner = Thread.current.object_id
 end
 def unlock_block
 @owner = nil
 unlock_write
 end
 def lock_read
 super unless my_block?
 end
 def unlock_read
 super unless my_block?
 end
 def lock_write
 super unless my_block?
 end
 def unlock_write
 super unless my_block?
 end
 def my_block?
 @owner == Thread.current.object_id
 end
end

# ======= unchanged copy-paste part from Michael Sofaer answer (end) =======


# global hash object, which will be 'shared' across threads
$h = LockedHash.new

# hash_reader is just iterating through the 'shared' hash $h
# and prints specified delimeter (capitalized when last hash item read)
def hash_reader(delim)
 loop{
 count = 0
 $h.each{
 count += 1
 if count != $h.size
 $stderr.print delim
 else
 $stderr.puts delim.upcase
 end
 }
 }
end

# fill hash with 10 items
10.times{|i|
 $h[i] = i
}

# create a thread which will read $h hash
t1 = Thread.new(){
 hash_reader("o")
}

t1.join # will never happen, but for completeness
</code></pre>

, which gives the following error:

<pre><code>./LockedHash_fails_to_unlock.rb
oooooooooO
./LockedHash_fails_to_unlock.rb:55:in `unlock': Attempt to unlock a mutex which is not locked (ThreadError)
 from ./LockedHash_fails_to_unlock.rb:55:in `unlock_write'
 from ./LockedHash_fails_to_unlock.rb:82:in `unlock_write'
 from ./LockedHash_fails_to_unlock.rb:70:in `unlock_block'
 from ./LockedHash_fails_to_unlock.rb:29:in `method_missing'
 from ./LockedHash_fails_to_unlock.rb:100:in `block in hash_reader'
 from ./LockedHash_fails_to_unlock.rb:98:in `loop'
 from ./LockedHash_fails_to_unlock.rb:98:in `hash_reader'
 from ./LockedHash_fails_to_unlock.rb:119:in `block in &lt;main&gt;'
</code></pre>

What's the best way to implement a Hash that can be modified across multiple threads, but with the smallest number of locks. For the purposes of this question, you can assume that the Hash will be read-heavy. It must be thread-safe in all Ruby implementations, including ones that operate in a truly simultaneous fashion, such as JRuby, and it must be written in pure-Ruby (no C or Java allowed).

Feel free to submit a naïve solution that always locks, but that isn't likely to be the best solution. Points for elegance, but a smaller likelihood of locking wins over smaller code.

Pure-Ruby concurrent Hash

Ruby语言

Java

实现可以跨多个线程修改但锁数量最少的Hash的最佳方式是什么？出于这个问题的目的，您可以假设Hash将是读取繁重的。它在所有的Ruby实现中都必须是线程安全的，包括那些真正同时操作的实现，比如JRuby，并且它必须用纯Ruby编写(不允许使用C或Java )。你可以随意提交一个天真的解决方案，但这不太可能是最好的解决方...

问纯Ruby并发哈希
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问纯Ruby并发哈希EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问纯Ruby并发哈希
EN