anchor.diff:  Think of a McDrive with one lane and very few customers arriving. The one lane is either free or there is one customer.
   Each customer orders always the same three "things", which you can prepare with 3 workers in the background "in parallel".
   
  -* Parallelism in a logical sense: We can do three things in parallel for one customer
  +* Parallelism in a sense of _different_ things in parallel: We can do three things in parallel for one customer
   * Based on the http://reactivex.io/documentation/operators/flatmap.html[flatmap] operator (Note: @Beta annotated in RxJava 1.0.14)
   
   In this example there is no need for backpressure, since the customers arrive "slow " and the McDrive can handle them in time.
  
positive.code: Let's come back from the food to the technical details. As initially said, RxJava is _"single threaded by default"_.
  Although you can offload the work from one thread to an other (using Schedulers), the program flow then is switching
  from one thread to another *one* thread and not to a pool of threads. Your sourcecode (e.g. your observer) is always called by
  only *one* and the *same* thread.
  
  So, to make it more clear: _"your sourcecode is always called by the same single thread"_.
  
  Benefit? You don't have to implement thread-safe code, which is hard.
negative.code: 
  b) _"While Rx has concurrency features, these should not be mistaken for a concurrency framework. Rx is designed for querying data, and as discussed in the first chapter, parallel computations or composition of asynchronous methods is more appropriate for other frameworks."_
  
  ==== My summary concerning threading and parallelsim with RxJava (1.0.14)
  
  Rx is created mainly for "clients" (client applications like apps, desktop gui applications, ...) where
  you have typically one thread from the GUI and you would like to "spin off" several background tasks (in parallel).
  
  Rx is excellent at that, at doing _different_ things in parallel.
  
  When it comes to doing _same_ things in parallel, like in a server where you handle hundreds of client calls in parallel,
  then Rx is not that straight forward. You start with creating Observables, using subscribeOn and flatMap, just to get
  _same_ things to run in parallel. Here are some examples for this.
  
  
  === OneLaneMcDrive
  
  