title: Parallel dispatch of `groupBy` groups in Reactor
body: <p>I'm learning <a href="http://projectreactor.io" rel="noreferrer" title="Reactor">Reactor</a>, and I'm wondering how to achieve a certain behavior.
  Let's say I have a stream of incoming messages.
  Each message is associated with a certain entity and contains some data.</p>
  
  <pre><code>interface Message {
      String getEntityId();
      Data getData();
  }
  </code></pre>
  
  <p>Messages relating to different entities can be processed in parallel.
  However, messages pertaining to any single entity must be processed one at a time, i.e. processing of message 2 for entity <code>"abc"</code> can not start until processing of message 1 for entity <code>"abc"</code> has finished.
  While processing of a message is underway, further messages for that entiy should be buffered.
  Message for other entities can proceed unimpeded.
  One can think of it as there being on thread per entity running code like this:</p>
  
  <pre><code>public void run() {
      for (;;) {
          // Blocks until there's a message available
          Message msg = messageQueue.nextMessageFor(this.entityId);
  
          // Blocks until processing is finished
          processMessage(msg);
      }
  }
  </code></pre>
  
  <p>How can I achieve this with React without blocking?
  The total message rate may be high, but message rate per entity will be very low.
  The set of entities can be very large, and is not necessarily known in advance.</p>
  
  <p>I guess it might look something like this, but I don't know.</p>
  
  <pre><code>{
      incomingMessages()
              .groupBy(Message::getEntityId)
              .flatMap(entityStream -&gt; entityStream
                      /* ... */
                      .map(msg -&gt; /* process the message */)))
                      /* ... */
  }
  
  public static Stream&lt;Message&gt; incomingMessages() { /* ... */ }
  </code></pre>