Thanks for reporting this.
There's indeed a bug which can lead to this deadlock.
Relevant code in Lib/multiprocessing/heap.py
- the BufferWrapper class uses a single Heap() shared among instances, protected by a mutex (threading.Lock), from which blocks are allocated
- when a BufferedWrapper is allocated, a multiprocessing.Finalizer is installed to free the corresponding block allocated from the Heap
- if another BufferedWrapper is garbage collected while the mutex protecting the Heap is held (in your case, while a new BufferedWrapper is allocated), the corresponding finalizer will try to free the block from the heap
- free tries to lock the mutex
- deadlock

The obvious solution is to use a recursive lock instead.
Could you try your application after changing:
"""
class Heap(object):

    _alignment = 8

    def __init__(self, size=mmap.PAGESIZE):     
        self._lastpid = os.getpid()     
        self._lock = threading.Lock()
"""

to
"""
class Heap(object):

    _alignment = 8

    def __init__(self, size=mmap.PAGESIZE):     
        self._lastpid = os.getpid()     
->      self._lock = threading.RLock()
"""

One could probably reproduce this by allocating and freeing many multiprocessing.Values, preferably with a lower GC threshold.