GeezerVison

Two constraints shape it: ctypes is not available on every platform, so
no multiprocessing.Value, and sem_getvalue() is broken on macOS, so a
semaphore can only be tested for zero. The state is four SemLocks:

• a flag for "shut down" and a flag for "shut down immediately";
• a count of the items accepted by put() in any process and not yet
  received. This is what tells a getter that the queue is really empty,
  rather than that the pipe happens to be empty;
• a lock. On macOS the zero test acquires and releases the semaphore, so two
  tests at the same moment can give a wrong answer. Every test whose answer
  matters is made under this lock, as is the "check the flag, count the
  item" step of put().

Nothing needs to know how many processes are waiting:

• Getters. shutdown() sends one empty message through the pipe, which
  can never be a valid pickle. The getter which reads it sends it back for
  the next one, and raises ShutDown only if nothing is outstanding;
  otherwise it waits for the item which is still on its way.
• Putters. shutdown() releases the queue's semaphore once if the queue
  is full. A putter which acquires it and finds the queue shut down releases
  it again, which wakes the next one.
• Immediate. The caller discards its own buffer and what is in the pipe.
  Feeder threads in other processes discard their buffers when they see the
  flag. On Unix the caller holds the write lock while it empties the pipe
  and leaves the marker in it, so an item which a feeder thread had already
  decided to send lands behind the marker and is thrown away by the next
  getter.

A queue which never calls shutdown() pays for one lock and two semaphore
operations per put(), and one semaphore operation per get(). A
subclass which overrides put() without counting its items keeps working.