title: Flux backpressure not applied
body: <p>I have an endless stream of events, which I want to:</p>
  
  <ol>
  <li>take into microbatches, 100ms each, or 10000 elements</li>
  <li>group them based on a grouping function</li>
  <li>process each list of grouped items in parallel </li>
  </ol>
  
  <p>my code looks like following:</p>
  
  <pre><code>Flux&lt;SuchEvent&gt; suchFlux = Flux.fromStream(events);
  Scheduler parallel = Schedulers.newParallel("asd", 64);
  suchFlux
              .bufferTimeout(10000, Duration.ofMillis(100))
              .map(rawEvents -&gt; {
                  Map&lt;UUID, List&lt;SuchEvent&gt;&gt; groupedEvents = new HashMap&lt;&gt;();
                  for (SuchEvent stuff : rawEvents) {
                      if (!groupedEvents.containsKey(stuff.getProfileId())) {
                          groupedEvents.put(stuff.getProfileId(), new ArrayList&lt;&gt;());
                      }
                      groupedEvents.get(stuff.getProfileId()).add(stuff);
                  }
                  return groupedEvents.values();
              })
              .subscribe(groupedEvents -&gt; {
                  for (List&lt;SuchEvent&gt; suchEvents : groupedEvents) {
                      Flux.fromIterable(suchEvents)
                          .subscribeOn(parallel)
                          .subscribe(suchEvent -&gt; {
                              //do stuff (this is fairly slow, each call takes 50ms)
                          });
                  }
              });
  </code></pre>
  
  <p>I'd expect the internal subscribe(suchEvent) to cause some backpressure to the producing, however, after running for a while everything seems to grind down to a halt. Where is the fallacy in my logic? </p>