Reactive Programming on Android with RxJava

particular operation should execute. When a
Scheduler
is specified along the
Observable
chain, the
Scheduler
will provide a worker that will run the actual block of code. The thread that the scheduled
work executes on depends on the
Scheduler
in use. There are several types of
Scheduler
s available
via factory methods in the
Schedulers
class:
•
Schedulers.newThread()
, as its name suggests, returns a
Scheduler
that will create a new
Thread
for each scheduled unit of work. As a result, using
Scheduler.newThread()
is
expensive since a new
Thread
is spawned each time–no reuse happens.
•
Schedulers.from(Executor executor)
returns a
Scheduler
that is backed by the specified
Executor
.

---

Chapter 4: Multithreading
50
•
Schedulers.single()
returns a
Scheduler
that is backed by a single thread. If several tasks are
scheduled in
Schedulers.single()
, the tasks are scheduled serially and will be executed in
order.
•
Schedulers.io()
provides a
Scheduler
that is meant for I/O-bound work such as network calls,
database transactions, etc. The underlying implementation uses an
Executor
thread pool that
will grow as needed. With I/O tasks, we are not doing CPU-intensive work; instead, we are
usually waiting on resources or services that may live on a different host, so being able to
create and assign a new thread to each task is ideal.
•
Schedulers.computation()
provides a
Scheduler
that is meant for computational or CPU-
intensive work such as processing a long list, resizing an image, etc. This
Scheduler
utilizes
a thread pool whose size is bounded by the number of available cores. Because we are
performing CPU-intensive work, creating more threads than cores will actually degrade
performance; both thread creation and context switching result in a lot of overhead without
helping to speed up our CPU-intensive work. The
.computation() Scheduler
should never be
used for I/O, and the
.io() Scheduler
should never be used for computational work; I/O and
computation block for completely different reasons thereby requiring completely different
threading strategies.
•