docs: private void waitGet_(long timeout) throws InterruptedException {
  
          // wait on a member of the lock array
          int lockIndex = getQueueIndex(getQueueLocks_, getQueueCounter_, true);
          synchronized (getQueueLocks_[lockIndex]) {
              try {
  
                  // increment waiting threads
                  getQueueLocks_[lockIndex].threadsWaiting++;
  
                  // D497382 - Now that we have the getQueue_ lock, recheck the
                  // condition from take/poll to try to minimize the number of
                  // threads that wait but don't get notified.
                  if (numberOfUsedSlots.get() <= 0) {
  
                      // determine timeout if unspecified
                      if (timeout < 0) {
                          if (WAIT_SHORT_SLICE_ != WAIT_LONG_SLICE_ && getQueueLocks_[lockIndex].shortWaiter == null) {
  
                              // use default timeout if not specified
                              timeout = WAIT_SHORT_SLICE_;
  
                              // there are no threads on waiting with short timeout,
                              // so this thread will use timeout value and set flag.
                              getQueueLocks_[lockIndex].shortWaiter = Thread.currentThread();
                          } else {
  
                              // there is already a thread on this queue waiting with
                              // short timeout set, so all other threads will wait a
                              // longer time to avoid contention of threads looking for
                              // work without being notified.
                              timeout = WAIT_LONG_SLICE_;
                          }
                      }
  
                      // notification through notifyGet_ may be lost here
                      getQueueLocks_[lockIndex].wait(timeout);
                  }
              } catch (InterruptedException ex) {
                  getQueueLocks_[lockIndex].notify();
                  throw ex;
              } finally {
  
                  // decrement waiting threads
                  getQueueLocks_[lockIndex].threadsWaiting--;
  
                  // check whether the current thread was waiting with a timeout.
                  // if so, need to clear the flag to indicate that no thread is
                  // waiting with timeout on this queue.
                  if (WAIT_SHORT_SLICE_ != WAIT_LONG_SLICE_)
                      if (getQueueLocks_[lockIndex].shortWaiter == Thread.currentThread())
                          getQueueLocks_[lockIndex].shortWaiter = null;
              }
          }
      }