Deadlock in Concurrent::Array's on non-MRI

Abierto

#627 abierto el 2/2/2017 4 comentarios 0 reacciones 0 asignados Ver en GitHub

Nadie ha tomado este issue todavía.

Evaluación

Dificultad: 5/5
Tiempo estimado: Más de una semana
Aptitud para principiantes: 25/100

Tipo de issue: Error
Claridad: Necesita aclaración
Estado de actividad: Estancado
Stack tecnológico: ruby
Área: backend

Línea de trabajo

Start with the linked gist and the Concurrent::Array documentation, then reproduce the behavior on MRI, JRuby, Rubinius, and TruffleRuby. Compare block-taking methods on Concurrent::Array and Concurrent::Hash; done requires a maintainer decision on intended locking semantics and whether behavior should be consistent across implementations.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

bug looking-for-contributor medium-priority

concurrent-ruby version: 1.0.4
concurrent-ruby-ext installed: no
concurrent-ruby-edge used: no

Take the following code: https://gist.github.com/eregon/323890bfff539f8a33f66d8b2f02cc99
Of course, its purpose is to create a deadlock but it means any method taking a block on Array can cause a deadlock as long as:

2+ threads use 2+ Concurrent::Array by calling a method taking a block
inside the blocks, the threads call any method taking on another Concurrent::Array

This seems not such a rare scenario, as it is frequent to call methods in a block that do not only involve the current Array.

The deadlock does not happen on MRI, as it uses a single global lock and concurrent-ruby just subclasses ::Array. It does happen on all other implementations though, like JRuby, Rubinius and TruffleRuby.

The documentation says:

A thread-safe subclass of Array.
This version locks against the object itself for every method call,
ensuring only one thread can be reading or writing at a time.
This includes iteration methods like #each.

So indeed this might imply the deadlock above, but it's not clear.
ensuring only one thread can be reading or writing at a time is also inaccurate on MRI for methods taking a block, as they release the GIL and might switch to another Thread in the middle of e.g. #each.

The same apply for Hash.

Is this behavior intended? Should this be fixed?
Should it behave the same on the different implementations?