Unexpected behavior with RxJava2 PublishSubject - rx-java2

Question

I have the following code which uses a PublishSubject.
val subject = PublishSubject.create<Int>()
val o1: Observable<String> =
subject.observeOn(Schedulers.newThread()).map { i: Int ->
println("${Thread.currentThread()} | ${Date()} | map => $i")
i.toString()
}
o1.subscribe {
println("${Thread.currentThread()} | ${Date()} | direct subscription (1) => $it")
}
o1.subscribe {
println("${Thread.currentThread()} | ${Date()} | direct subscription (2) => $it")
}
o1.subscribe {
println("${Thread.currentThread()} | ${Date()} | direct subscription (3) => $it")
}
println("${Thread.currentThread()} | ${Date()} | submitting 1")
subject.onNext(1)
1) I create an Observable from it and map it (for the purpose of this example I am just converting to a String) => o1.
2) I then subscribe to o1 3 times.
3) Finally I "publish" an event by calling subject.onNext(1).
To my surprise I am getting the following output:
Thread[main,5,main] | Mon Jun 19 09:46:37 PDT 2017 | submitting 1
Thread[RxNewThreadScheduler-1,5,main] | Mon Jun 19 09:46:37 PDT 2017 | map => 1
Thread[RxNewThreadScheduler-2,5,main] | Mon Jun 19 09:46:37 PDT 2017 | map => 1
Thread[RxNewThreadScheduler-3,5,main] | Mon Jun 19 09:46:37 PDT 2017 | map => 1
Thread[RxNewThreadScheduler-1,5,main] | Mon Jun 19 09:46:37 PDT 2017 | direct subscription (1) => 1
Thread[RxNewThreadScheduler-2,5,main] | Mon Jun 19 09:46:37 PDT 2017 | direct subscription (2) => 1
Thread[RxNewThreadScheduler-3,5,main] | Mon Jun 19 09:46:37 PDT 2017 | direct subscription (3) => 1
map ends up being called 3 times and I don't understand why since I am subscribing to o1 which should happen after map has occurred. I must be missing something. Any help would be appreciated.
Thanks
Yan

Answer 1

From the comments:
You subscribe to o1 three times, each creating an independent sequence up until the PublishSubject that will dispatch the onNext to all 3 chains.
From the perspective of all 3 subscribers, PublishSubject is a multicasting source that signals events to them through independent chains established by the subscribe() calls.
Applying operators on a Subject generally don't make the whole chain hot because those operator elements only get attached to the source Subject only when they are subscribed to. Thus, multiple subscriptions will yield multiple channels to the same upstream Subject.
Use publish to get a ConnectableObservable (or another PublishSubject at the very end) to make the sequence hot from that point on.