Kung matagal ka nang nakikipagbuno sa mga operator ng RxJava, malamang napansin mo na nagbabago ang sitwasyon. Bagama't ang RxJava ang naging pangunahing gamit sa loob ng maraming taon para sa paghawak ng asynchronicity sa Android, Mga coroutine ni Kotlin Dumating ang mga ito para gawing mas mapadali ang ating mga buhay, na nag-aalok ng mas madaling gamiting paraan upang maiwasan ang pag-freeze ng ating mga app habang pinoproseso ang data.
Ang transisyon ay hindi lamang usapin ng moda, kundi ng kahusayan at kakayahang mabasaAng paglipat mula sa isang kumplikadong reactive flow patungo sa isang suspended model ay nagbibigay-daan sa code na lumitaw nang sunud-sunod kahit na tumatakbo sa background, na nag-aalis ng karamihan sa pagiging masalita at ang tipikal na "callback hells" na nagtulak sa amin na sumuko sa malalaking proyekto gamit ang Kotlin programming language.
Ang mga haligi ng Coroutine: Mga Dispatcher, Trabaho, at Concurrency
Upang maunawaan kung paano gumagana ang ecosystem na ito, kailangan mo munang maunawaan ang mga pangunahing kaalaman. despatsador Ito talaga ang nagpapasya kung saang thread tatakbo ang bawat gawain. Mayroon tayo Dispatchers.Main upang makipag-ugnayan sa user interface, Dispatchers.IO na-optimize para sa pagbabasa ng mga file o mga kahilingan sa network, at Dispatchers.Default Para sa mga gawaing nangangailangan ng maraming CPU, tulad ng pagproseso ng isang malaking JSON file, kasunod ng Wastong Paggamit ng mga Dispatcher.
Sa kabilang banda, Trabaho Ito ang nagsisilbing remote control para sa ating coroutine; pinapayagan tayo nitong subaybayan ang lifecycle nito at, higit sa lahat, kanselahin ito kung hindi na natin ito kailangan. Kapag pinagsama natin ito sa CoroutineScopePapasok na tayo ngayon sa larangan ng structured concurrency. Nangangahulugan ito na kung kakanselahin natin ang isang scope, lahat ng mga anak nito ay matatapos kasama nito, kaya pinipigilan ang mga prosesong "zombie" na kumonsumo ng baterya at memorya sa device ng gumagamit.
Mga pangunahing pagkakaiba at refactoring
Ang pangunahing pagkakaiba ay pinipilit tayo ng RxJava na mag-isip nang reaktibo, kahit na simple lang ang lohika. Sa kabilang banda, ang mga Coroutine ay nagpapakilala ng mga function. suspindihin at ipagpatuloyAng isang suspendidong function ay humihinto sa pagpapatupad, sine-save ang kasalukuyang estado, at nagpapatuloy kung saan ito tumigil kapag natapos na ang gawain, nang hindi hinaharangan ang pangunahing thread.
- ilunsadGinagamit ito para sa mga gawaing "shoot and forget", kung saan hindi natin kailangan ng resultang ibinalik.
- asyncMainam kapag kailangan nating makakuha ng isang halaga, na nagpapahintulot sa atin na gamitin
await()para maghintay ng tugon. - mayKontekstoIto ang pangunahing kagamitan para sa pagpapalit ng mga thread sa loob ng isang suspendidong function nang hindi naaapektuhan ang daloy ng code.
Sa pag-refactor, mapapansin natin na ang code ay nagiging hindi gaanong madaldalKung dati ay mayroon tayong walang katapusang hanay ng mga operator ng RxJava, maaari na tayong magkaroon ngayon ng malinaw at direktang mga bloke ng code. Halimbawa, ang paghawak ng error ay hindi na nangangailangan ng mga kumplikadong bloke ng onError sa bawat subscription, ngunit mas natural natin itong mapamahalaan gamit ang mga try-catch block o gamit ang isang CoroutineExceptionHandler para sa mga pandaigdigang pagkabigo.
Katayuan ng UI: Mula LiveData hanggang StateFlow
Sa proseso ng paglipat, karaniwan nang pinapalitan ang LiveData ng StateFlowHindi tulad ng unang paraan, ang StateFlow ay laging mayroong tinukoy na initial state at ginagarantiyahan na ang value ay hindi magiging null kapag naobserbahan. Bukod pa rito, hindi mahalaga kung saang thread tayo naroroon kapag ina-update ang value, na nagbibigay ng brutal na kakayahang umangkop sa pag-unlad sa pamamagitan ng Modernong kakayahang tumugon gamit ang StateFlow at SharedFlow.
Gayunpaman, ipinapayong mag-ingat dahil hindi alam ng StateFlow ang default na lifecycle. Upang matugunan ito, karaniwan naming ginagamit ang launchWhenStarted sa loob ng a LifecycleCoroutineScopetinitiyak na ang mga kaganapan sa UI ay pinoproseso lamang kapag aktibo ang screen at manu-manong kinakansela ang saklaw sa onStop para maiwasan ang mga tagas ng memorya.
Pagganap at mga pangwakas na pagsasaalang-alang
Sa usapin ng kapangyarihan, ang mga coroutine ay mas magaan at mas mabilis kaysa sa mga tradisyonal na thread o mabibigat na implementasyon ng RxJava. Sa pamamagitan ng hindi pagharang sa mga thread, kayang pangasiwaan ng sistema ang libu-libong coroutine nang sabay-sabay nang hindi pinagpapawisan. Maipapayo na iwasan ang paggamit GlobalScope Sa mga aplikasyon sa totoong mundo, nagiging mas mahirap ang unit testing at pamamahala ng lifecycle; mas mainam na gamitin ang mga saklaw na ibinibigay ng Android, tulad ng viewModelScope.
Ang paglipat sa modelong ito ay nagbibigay-daan sa amin upang magsulat ng mas matatag na mga aplikasyon, kung saan ang seguridad ng pangunahing thread Natitiyak ito sa pamamagitan ng matalinong paggamit ng mga dispatcher at nakabalangkas na concurrency, na ginagawang mapaghihiwalay, masusubok at, higit sa lahat, mas madaling mapanatili ang business logic sa pangmatagalan. Ibahagi ang impormasyong ito upang mas maraming tao ang matuto tungkol sa paksa.