docs: public void queueNotification(
              final Collection<ClientInterfaceHandleManager> connections,
              final Supplier<DeferredSerialization> notification,
              final Predicate<ClientInterfaceHandleManager> wantsNotificationPredicate) {
          m_submissionQueue.offer(new Runnable() {
              @Override
              public void run() {
                  for (ClientInterfaceHandleManager cihm : connections) {
                      if (!wantsNotificationPredicate.apply(cihm)) continue;
                      final Connection c = cihm.connection;
  
                      /*
                       * To avoid extra allocations and promotion we initially store a single event
                       * as just the event. Once we have two or more events we create a linked list
                       * and walk the list to dedupe events by identity
                       */
                      Object pendingNotifications = m_clientsPendingNotification.get(c);
                      try {
                          if (pendingNotifications == null) {
                              m_clientsPendingNotification.put(c, notification);
                          } else if (pendingNotifications instanceof Supplier) {
                              //Identity duplicate check
                              if (pendingNotifications == notification) return;
                              //Convert to a two node linked list
                              @SuppressWarnings("unchecked")
                              Node n1 = new Node((Supplier<DeferredSerialization>)pendingNotifications, null);
                              n1 = m_cachedNodes.get(n1, n1);
                              Node n2 = new Node(notification, n1);
                              n2 = m_cachedNodes.get(n2, n2);
                              m_clientsPendingNotification.put(c,  n2);
                          } else {
                              //Walk the list and check if the notification is a duplicate
                              Node head = (Node)pendingNotifications;
                              boolean dup = false;
                              while (head != null) {
                                  if (head.notification == notification) {
                                      dup = true;
                                      break;
                                  }
                                  head = head.next;
                              }
                              //If it's a dupe, no new work
                              if (dup) continue;
                              //Otherwise replace the head of the list which is the value in the map
                              Node replacement = new Node(notification, (Node)pendingNotifications);
                              replacement = m_cachedNodes.get(replacement, replacement);
                              m_clientsPendingNotification.put(c, replacement);
                          }
                      } catch (ExecutionException e) {
                          VoltDB.crashLocalVoltDB(
                                  "Unexpected exception pushing client notifications",
                                  true,
                                  Throwables.getRootCause(e));
                      }
                  }
              }
          });
      }