web-dev-qa-db-fra.com

L'ordre d'abonnement et d'observation est-il important?

Je suis un peu confus quant à l'ordre dans lequel vous pouvez appeler les méthodes subscribeOn et observeOn sur les observables. J'ai lu quelques articles et un gars dit que cela n'a pas d'importance et utilise simplement quelque chose dans son exemple et d'autres personnes disent que cela a de l'importance. Voici donc ma question:

Par exemple:

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)

Est-ce la même chose 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 je comprends bien les mécanismes, ils sont différents. Le premier effectue tout le travail sur le thread principal et le second effectue tout le travail sur un autre thread, puis est renvoyé vers le thread principal. Mais je suis sûr que quelqu'un peut effacer cela pour moi s'il vous plaît?

swiftmultithreadingrx-swift
30
user1007522

L'endroit où vous appelez subscribeOn() dans une chaîne n'a pas vraiment d'importance. L'endroit où vous appelez observeOn() importe.

subscribeOn () indique à toute la chaîne sur quel thread démarrer le traitement. Vous ne devez l'appeler qu'une seule fois par chaîne. Si vous l'appelez à nouveau plus bas dans le flux, cela n'aura aucun effet.

observeOn () provoque l'exécution de toutes les opérations qui se produisent en dessous sur l'ordonnanceur spécifié. Vous pouvez l'appeler plusieurs fois par flux pour vous déplacer entre différents threads.

Prenons l'exemple suivant:

doSomethingRx()
    .subscribeOn(BackgroundScheduler)
    .doAnotherThing()
    .observeOn(ComputationScheduler)
    .doSomethingElse()
    .observeOn(MainScheduler)
    .subscribe(//...)
  • subscribeOn provoque l'appel de doSomethingRx sur le BackgroundScheduler.
  • doAnotherThing continuera sur BackgroundScheduler
  • puis observeOn bascule le flux vers le ComputationScheduler
  • doSomethingElse se produira sur le ComputationScheduler
  • un autre observeOn bascule le flux vers le MainScheduler
  • abonnement se produit sur le MainScheduler
58
Jahnold

L'opérateur .subscribeOn () affecte la chaîne de sheduler qui sera créée (à sa gauche) et cela fonctionnera une fois. .observeOn () influence l'opérateur à sa droite - sur quels ordonnanceurs les données seront traitées après l'opérateur.

1
Alex Shutov

Oui, tu as raison. observeOn ne recevra que les événements sur le thread que vous avez spécifié, tandis que subscribeOn exécutera le travail dans le thread spécifié.

1
solidcell