swift - react - ¿Importa el orden de suscripción y observación?

rxswift do

Question

Estoy un poco confundido acerca del orden en que puede llamar a los métodos de subscribeOn y observeOn en observables. Leí un par de publicaciones y uno de ellos dice que no importa y solo usa algo en su ejemplo y otras personas dicen que sí importa. Ésta es mi pregunta:

Por ejemplo:

self.remoteService.rxGetAllLanguages()
            .observeOn(MainScheduler.instance)
            .subscribeOn(ConcurrentDispatchQueueScheduler(globalConcurrentQueueQOS: .Background))
            .subscribe({ e in
                switch e {
                case .Next(let element):

                case .Error(let e):
                    DDLogError("Error in  /(e)")
                case .Completed:
                    DDLogDebug("Completed")
                }
                }
            ).addDisposableTo(self.disposeBag)

Es lo mismo que

  self.remoteService.rxGetAllLanguages()
                    .subscribeOn(ConcurrentDispatchQueueScheduler(globalConcurrentQueueQOS: .Background))
                    .observeOn(MainScheduler.instance)
                    .subscribe({ e in
                        switch e {
                        case .Next(let element):

                        case .Error(let e):
                            DDLogError("Error in  /(e)")
                        case .Completed:
                            DDLogDebug("Completed")
                        }
                        }
                    ).addDisposableTo(self.disposeBag)

Si entiendo correctamente los mecanismos son diferentes. El primero hace todo el trabajo en el hilo principal y el segundo hace todo el trabajo en otro hilo y luego vuelve al hilo principal. Pero estoy seguro, ¿puede alguien aclararme esto por favor?

Answer 1

Donde llames subscribeOn() en una cadena realmente no importa. Donde llames observeOn() sí importa.

subscribeOn () le dice a toda la cadena en qué hilo comenzar a procesar. Solo deberías llamarlo una vez por cadena. Si lo vuelves a llamar más abajo en la secuencia, no tendrá ningún efecto.

observeOn () hace que todas las operaciones que suceden debajo de él se ejecuten en el planificador especificado. Puede llamarlo varias veces por secuencia para moverse entre diferentes hilos.

Tomemos el siguiente ejemplo:

doSomethingRx()
    .subscribeOn(BackgroundScheduler)
    .doAnotherThing()
    .observeOn(ComputationScheduler)
    .doSomethingElse()
    .observeOn(MainScheduler)
    .subscribe(//...)

• doSomethingRx hace que se llame a doSomethingRx en el BackgroundScheduler.
• doAnotherThing continuará en BackgroundScheduler
• a continuación, observeOn cambia el flujo al ComputationScheduler
• doSomethingElse sucederá en el programador de computación
• otra observeOn cambia el flujo al MainScheduler
• suscribirse sucede en el MainScheduler

Answer 2

El operador .subscribeOn () afecta a qué cadena de sheduler se creará (a la izquierda de la misma) y funcionará una vez. .observeOn () influye en el operador a su derecha, sobre qué datos de los programadores se procesarán después del operador.

Answer 3

Si estas en lo correcto observeOn solo recibirá los eventos en el hilo que ha especificado, mientras que subscribeOn realmente ejecutará el trabajo dentro del hilo especificado.