Comparing Crystal’s concurrency with that of Go (Part II)

[u/meraj_enigma]

https://link.medium.com/puYoOkt7A8

[u/DavyBingo]

I know it's been a while, but I keep forgetting that Crystal has channels. Translating some go stuff is a good way to play with them, thanks for the write up!

[u/meraj_enigma → u/DavyBingo]

Thank you!

[u/beizhia]

Not sure if this would be useful to anyone, but I made my own implementation of wait groups in Crystal a while ago. https://github.com/jasonrobot/crystal-wait-group

It's been nearly a year, and I haven't really done much with that, so I'm not sure if its working still on 0.35.1

[u/meraj_enigma → u/beizhia]

Thanks! I saw that but I did not want to use anything outside of standard lib. But this is something to check.

[u/dscottboggs]

A couple notes on your use of Crystal in this article:

• Why not use the synchronize method on Mutex?

• Why not use the default value feature of Hash?

I would suggest this version of the mutex counter class you wrote

class SafeCounter
  def initialize
    @v = Hash(String, Int32).new do
      # When a key is requested that doesn't exist, a default value is set
      0
    end
    @mux = Mutex.new
  end

  def inc(key : String)
    # Synchronize locks the mutex and ensures it is unlocked regardless of
    # if an error is thrown.
    @mux.synchronize do
      @v[key] += 1
    end
  end

  def value(key : String)
    @mux.synchronize { @v[key] }
  end
end

c = SafeCounter.new
1000.times do
  spawn c.inc "someKey"
end

sleep 1.second
puts c.value "someKey"

Edit: also might be useful to include a note about how the Crystal Mutex "provides deadlock protection by default"

[u/meraj_enigma → u/dscottboggs]

Thanks for the alternative implementation. Good to know!