Planificadores y subprocesos
Controle la ejecución con receive(on:) y subscribe(on:).
Planificadores y subprocesos es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.
Schedulers en Combine
Un scheduler en Combine define cuándo y dónde se ejecuta el trabajo: qué subproceso o cola ejecuta los operadores y entrega los valores a los suscriptores.
Controlar los schedulers es esencial para mantener las actualizaciones de la interfaz en el subproceso principal y ejecutar fuera de él las tareas pesadas.
Dos operadores clave
Combine proporciona dos operadores para controlar los subprocesos:
- subscribe(on:): controla dónde comienza la suscripción y el trabajo upstream
- receive(on:): controla dónde se entregan los valores downstream
Afectan a extremos diferentes de la pipeline.
receive(on:)
receive(on:) mueve todo lo que está después de él al scheduler indicado. El uso más habitual es volver a la cola principal antes de actualizar la interfaz.
apiClient.fetchUser(id: 1)
.receive(on: DispatchQueue.main)
.sink { user in
self.nameLabel.text = user.name
}
.store(in: &cancellables)subscribe(on:)
subscribe(on:) controla el subproceso en el que el publisher comienza a producir valores y donde se ejecutan los operadores upstream. Úselo para sacar del subproceso principal la configuración costosa.
heavyPublisher
.subscribe(on: DispatchQueue.global(qos: .userInitiated))
.receive(on: DispatchQueue.main)
.sink { result in
self.update(result)
}
.store(in: &cancellables)subscribe(on:) frente a receive(on:)
Recuerde las direcciones:
- subscribe(on:) afecta al flujo upstream: dónde comienza el trabajo
- receive(on:) afecta al flujo downstream: dónde se entregan los resultados
Un patrón habitual usa subscribe(on:) para el trabajo en segundo plano y receive(on:) para entregar los resultados en el subproceso principal.
DispatchQueue como scheduler
DispatchQueue se ajusta al protocolo Scheduler. DispatchQueue.main realiza las entregas en el subproceso principal; las colas globales se ejecutan de forma concurrente en segundo plano.
let background = DispatchQueue.global(qos: .background)
publisher
.map { expensiveTransform($0) }
.subscribe(on: background)
.receive(on: DispatchQueue.main)
.sink { self.render($0) }
.store(in: &cancellables)RunLoop como scheduler
RunLoop es otro scheduler, vinculado al run loop de un subproceso. RunLoop.main realiza las entregas en coordinación con los eventos de la interfaz, lo que puede ser importante para aspectos como la capacidad de respuesta durante el desplazamiento.
timerPublisher
.receive(on: RunLoop.main)
.sink { _ in
self.tick()
}
.store(in: &cancellables)DispatchQueue frente a RunLoop
Ambos pueden realizar entregas en el subproceso principal, pero presentan diferencias sutiles:
- DispatchQueue.main: programa el trabajo incluso durante el seguimiento del desplazamiento
- RunLoop.main: pospone el trabajo mientras el run loop está en modo de seguimiento
Para la mayoría de las actualizaciones de la interfaz después de un trabajo asíncrono, DispatchQueue.main es la opción predeterminada más segura.
Operadores de temporización de schedulers
Los operadores como debounce, throttle y delay reciben un argumento scheduler que decide qué cola gestiona su temporización.
searchTextPublisher
.debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
.sink { query in
self.runSearch(query)
}
.store(in: &cancellables)Un error habitual con los subprocesos
Actualizar la interfaz fuera del subproceso principal provoca bloqueos o errores visuales. Si olvida receive(on: DispatchQueue.main) después de un publisher en segundo plano, es posible que su sink se ejecute en un subproceso secundario.
Realice siempre las entregas de valores destinados a la interfaz mediante el scheduler principal.
Ponerlo todo en conjunto
Una pipeline sólida inicia el trabajo en segundo plano, lo procesa allí y después entrega el resultado al subproceso principal para mostrarlo.
imageURLPublisher
.subscribe(on: DispatchQueue.global())
.flatMap { url in downloadImage(url) }
.map { resize($0) }
.receive(on: DispatchQueue.main)
.sink { self.imageView.image = $0 }
.store(in: &cancellables)Comprobación rápida
Compruebe sus conocimientos sobre los schedulers.
Resumen
Ha aprendido a controlar los subprocesos en Combine:
- subscribe(on:): dónde comienza el trabajo upstream
- receive(on:): dónde se entregan los resultados
- DispatchQueue y RunLoop como schedulers
- Realice siempre las actualizaciones de la interfaz en el subproceso principal
Una programación adecuada mantiene las aplicaciones ágiles y sin bloqueos.
Preguntas frecuentes
¿La lección «Planificadores y subprocesos» es gratis?
Sí — el texto completo de «Planificadores y subprocesos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Planificadores y subprocesos»?
Controle la ejecución con receive(on:) y subscribe(on:). Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Swift Academy?
No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Planificadores y subprocesos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Swift Academy?
Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Transformar y combinar flujos
- Planificadores y subprocesos
- Operadores de gestión de errores
- Publishers y Subscribers personalizados