Databases
StackOverflow2013
Postsdbo
PO
 

Note that there are some explanatory texts on larger screens.

plurals
  1. PO
    primarykey
    data
    text
    <p>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.</p> <p>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.</p> <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>
    singulars
    1. This table or related slice is empty.
    1. POPure-Ruby concurrent Hash
      singulars
      1. PTQuestion
    1. PTAnswer
    1. USuser456584
    1. USara t howard
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. POPure-Ruby concurrent Hash
      singulars
      1. PTQuestion
    1. This table or related slice is empty.
    1. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTAcceptedByOriginator
    2. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    3. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    1. COSorry it took me so long to get back to reading this. I actually really like this, but I'm a bit uncomfortable by your assertion that "this is only a problem in JRuby." That may well be true today (or it might not be, once implementations like macruby and maglev are taken into consideration), but it can hardly be taken as a given into the future. In fact, I wouldn't be all that surprised if Ruby 2.0 managed to avoid the GIL altogether in favor of finer grained locks. And it will likely be an issue in Maglev, MacRuby, and possibly Rubinius.
      singulars
      1. PO
      1. USYehuda Katz
    2. COI'm accepting this solution; it would be nice to see some benchmarks against the naïvely implemented locking solution.
      singulars
      1. PO
      1. USYehuda Katz
    3. COI'd also like to see benchmarks against Josh's copy-and-swap solution (which we use in Rails, and was my original stab at this problem)
      singulars
      1. PO
      1. USYehuda Katz
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload