đ Dispatcher in Kotlin: āϏāĻšāĻ āĻাāώাāϝ় āĻŦ্āϝাāĻ্āϝা
đ Dispatcher in Kotlin: āϏāĻšāĻ āĻাāώাāϝ় āĻŦ্āϝাāĻ্āϝা
Dispatcher āĻšāϞ āĻāĻāĻি āύিāϰ্āĻĻেāĻļāĻ, āϝা āĻোāĻāϞিāύেāϰ Coroutine āĻুāϞোāĻে āĻŦāϞে āĻĻেāϝ় āĻোāύ āĻĨ্āϰেāĻĄ āĻŦা āĻĨ্āϰেāĻĄāĻĒুāϞে āϰাāύ āĻāϰāϤে āĻšāĻŦে। āĻāĻি āĻŽুāϞāϤ āĻাāĻেāϰ āϧāϰāύ āĻ āύুāϝাāϝ়ী āĻ িāĻ āĻāϰে āĻĻেāϝ়, āĻাāĻāĻি CPU-āĻিāϤ্āϤিāĻ āĻšāĻŦে āύাāĻি I/O-āĻিāϤ্āϤিāĻ!
đ¯ Dispatcher āĻেāύ āĻĻāϰāĻাāϰ?
āϤুāĻŽি āĻি āĻাāĻāĻŦে āϝে āύেāĻāĻāϝ়াāϰ্āĻ āĻāϞ āĻŦা āĻĄাāĻাāĻŦেāϏ āĻ
āĻĒাāϰেāĻļāύ CPU-āϤে āĻŦেāĻļি āϞোāĻĄ āĻĻিāĻ? đ¤
āĻāĻŦং āϤুāĻŽি āĻি āĻাāĻ āĻাāĻŖিāϤিāĻ āĻšিāϏাāĻŦ āĻāĻāĻ āĻĨ্āϰেāĻĄে āĻāϞুāĻ āϝেāĻাāύে UI āϰাāύ āĻāϰে? āύা! đ
Dispatcher āĻāĻ āϏāĻŽāϏ্āϝাāϰ āϏāĻŽাāϧাāύ āĻāϰে:
- đ CPU āĻাāĻে āĻāϞাāĻĻা āĻĨ্āϰেāĻĄāĻĒুāϞ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে
- đ I/O (āύেāĻāĻāϝ়াāϰ্āĻ, āĻĢাāĻāϞ āϏিāϏ্āĻেāĻŽ)-āĻāϰ āĻāύ্āϝ āĻāϞাāĻĻা āĻĨ্āϰেāĻĄ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে
- đ˛ UI āĻāϰ āĻাāĻ āĻļুāϧুāĻŽাāϤ্āϰ Main āĻĨ্āϰেāĻĄে āϰাāĻāϤে āϏাāĻšাāϝ্āϝ āĻāϰে
đ¯ Dispatcher-āĻāϰ āϧāϰāύāϏāĻŽূāĻš
1️⃣ Dispatchers.Main → UI āĻাāĻেāϰ āĻāύ্āϝ
đ āϝāĻāύ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāĻŦো?
- UI āĻĒāϰিāĻŦāϰ্āϤāύ (Text, Button Update, Animation)
- āĻŦ্āϝāĻŦāĻšাāϰāĻাāϰীāϰ āĻāύāĻĒুāĻ āϏংāĻ্āϰাāύ্āϤ āĻাāĻ
import kotlinx.coroutines.*
fun main() = runBlocking {
launch(Dispatchers.Main) { // UI Thread
println("đ˛ UI āĻাāĻ āĻāϞāĻে: ${Thread.currentThread().name}")
}
}
đ āϏāĻŽāϏ্āϝা:
Main Dispatcher runBlocking-āĻ āĻাāĻ āĻāϰāĻŦে āύা, āĻাāϰāĻŖ āĻāĻি āĻļুāϧুāĻŽাāϤ্āϰ Android UI Thread-āĻ āĻāϞে!
2️⃣ Dispatchers.IO → I/O āĻাāĻেāϰ āĻāύ্āϝ
đ āϝāĻāύ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāĻŦো?
- āύেāĻāĻāϝ়াāϰ্āĻ āĻāϞ (API, Retrofit)
- āĻĄাāĻাāĻŦেāϏ āĻ āĻĒাāϰেāĻļāύ (Room, SQLite)
- āĻĢাāĻāϞ āĻĒāĻĄ়া-āϞেāĻা
import kotlinx.coroutines.*
fun main() = runBlocking {
launch(Dispatchers.IO) {
println("đ I/O āĻাāĻ āĻāϞāĻে: ${Thread.currentThread().name}")
}
}
✅ āĻāĻ Dispatcher āĻāϞাāĻĻা āĻĨ্āϰেāĻĄ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āϝাāϤে Main Thread āĻŦ্āϞāĻ āύা āĻšāϝ়!
3️⃣ Dispatchers.Default → Heavy CPU āĻাāĻেāϰ āĻāύ্āϝ
đ āϝāĻāύ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāĻŦো?
- āĻাāĻŖিāϤিāĻ āĻšিāϏাāĻŦ (Matrix Computation, Sorting)
- Machine Learning Processing
- Heavy Data Processing
import kotlinx.coroutines.*
fun main() = runBlocking {
launch(Dispatchers.Default) {
println("⚡ CPU āĻাāĻ āĻāϞāĻে: ${Thread.currentThread().name}")
}
}
✅ āĻāĻ Dispatcher CPU-āϰ āĻোāϰ āϏংāĻ্āϝা āĻ āύুāϝাāϝ়ী āĻĨ্āϰেāĻĄ āϤৈāϰি āĻāϰে।
4️⃣ Dispatchers.Unconfined → āĻāĻে āϝে āĻĨ্āϰেāĻĄ āĻিāϞ āϏেāĻাāϤে āĻাāĻ āĻাāϞাāĻŦে
đ āϝāĻāύ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāĻŦো?
- āĻুāĻŦ āĻāĻŽ āĻŦ্āϝāĻŦāĻšৃāϤ āĻšāϝ়, āĻিāĻু āĻĒāϰীāĻ্āώাāĻŽূāϞāĻ āĻাāĻে āĻĻāϰāĻাāϰ āĻšāϤে āĻĒাāϰে
import kotlinx.coroutines.*
fun main() = runBlocking {
launch(Dispatchers.Unconfined) {
println("đ āĻĒ্āϰāĻĨāĻŽ āĻĨ্āϰেāĻĄ: ${Thread.currentThread().name}")
delay(1000)
println("đ āĻĒāϰে āĻĨ্āϰেāĻĄ: ${Thread.currentThread().name}")
}
}
✅ āĻāĻি āĻĒ্āϰāĻĨāĻŽে āĻāĻ āĻĨ্āϰেāĻĄে āĻļুāϰু āĻšāϤে āĻĒাāϰে, āĻĒāϰে āĻ āύ্āϝ āĻĨ্āϰেāĻĄেāĻ āĻāϞে āϝেāϤে āĻĒাāϰে!
5️⃣ newSingleThreadContext → āĻāĻāĻি āύিāϰ্āĻĻিāώ্āĻ āĻĨ্āϰেāĻĄে āϏāĻŦ āĻাāĻ āĻাāϞাāύো āĻšāĻŦে
đ āϝāĻāύ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāĻŦো?
- āĻāĻ্āϏāĻĒেāϰিāĻŽেāύ্āĻাāϞ āĻাāĻেāϰ āĻāύ্āϝ
- āĻāĻāĻি āύিāϰ্āĻĻিāώ্āĻ āĻĨ্āϰেāĻĄ āϰাāĻāϤে āĻাāĻāϞে
import kotlinx.coroutines.*
fun main() = runBlocking {
val myDispatcher = newSingleThreadContext("MyThread")
launch(myDispatcher) {
println("đ āύিāϰ্āĻĻিāώ্āĻ āĻĨ্āϰেāĻĄ āĻāϞāĻে: ${Thread.currentThread().name}")
}
}
✅ āϏāĻŦ āĻাāĻ āύিāϰ্āĻĻিāώ্āĻ āĻāĻāĻি āĻĨ্āϰেāĻĄে āĻāϞāĻŦে। āϤāĻŦে āĻŦেāĻļি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϞে āĻĒাāϰāĻĢāϰāĻŽ্āϝাāύ্āϏ āĻāĻŽে āϝেāϤে āĻĒাāϰে!
đ Dispatcher āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āĻāĻāϏাāĻĨে āĻāĻাāϧিāĻ āĻাāĻ āĻāϰা
import kotlinx.coroutines.*
fun main() = runBlocking {
launch(Dispatchers.IO) {
println("đ āύেāĻāĻāϝ়াāϰ্āĻ āĻĨেāĻে āĻĄাāĻা āύিāĻ্āĻি: ${Thread.currentThread().name}")
}
launch(Dispatchers.Default) {
println("⚡ āĻĄাāĻা āĻĒ্āϰāϏেāϏ āĻāϰāĻি: ${Thread.currentThread().name}")
}
launch(Dispatchers.Main) {
println("đ˛ UI āĻāĻĒāĻĄেāĻ āĻāϰāĻি: ${Thread.currentThread().name}")
}
}
✅ āĻĒ্āϰāϤ্āϝেāĻāĻি āĻাāĻ āĻāϞাāĻĻা Dispatcher-āĻ āĻāϞāĻŦে, āĻĢāϞে CPU āĻ UI āĻŦ্āϞāĻ āĻšāĻŦে āύা!
đ¯ Dispatcher āĻĒāϰিāĻŦāϰ্āϤāύ āĻāϰা (Switch Context)
āϧāϰো, āϤুāĻŽি āύেāĻāĻāϝ়াāϰ্āĻ āĻĨেāĻে āĻĄাāĻা āύিāϝ়ে UI āĻāĻĒāĻĄেāĻ āĻāϰāϤে āĻাāĻ!
import kotlinx.coroutines.*
fun main() = runBlocking {
launch(Dispatchers.IO) {
val data = fetchData()
withContext(Dispatchers.Main) {
println("đ˛ UI āϤে āĻāĻĒāĻĄেāĻ āĻāϰāĻি: $data")
}
}
}
suspend fun fetchData(): String {
delay(2000)
return "đ āϏাāϰ্āĻাāϰ āĻĨেāĻে āĻĄাāĻা āĻāϏāϞো!"
}
✅ withContext(Dispatchers.Main) āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে Main Thread-āĻ āĻĢেāϰāϤ āĻāϏāϞাāĻŽ!
đ Dispatcher āϏেāϰা āĻ āύুāĻļীāϞāύ (Best Practices)
✅ UI āĻাāĻেāϰ āĻāύ্āϝ Dispatchers.Main āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো
✅ āύেāĻāĻāϝ়াāϰ্āĻ āĻ āĻĄাāĻাāĻŦেāϏেāϰ āĻāύ্āϝ Dispatchers.IO āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো
✅ āĻাāĻŖিāϤিāĻ āĻ āĻšেāĻি āĻĒ্āϰāϏেāϏিং-āĻāϰ āĻāύ্āϝ Dispatchers.Default āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো
✅ Switch Context āĻāϰāϤে withContext() āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো
✅ Unconfined āĻ newSingleThreadContext āĻŦেāĻļি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻāĻĄ়িāϝ়ে āĻāϞো
đ āϏংāĻ্āώেāĻĒে Dispatcher
| Dispatcher | āĻŦ্āϝāĻŦāĻšাāϰ āĻ্āώেāϤ্āϰ | āĻĨ্āϰেāĻĄ āĻŦ্āϝāĻŦāĻšাāϰেāϰ āύিāϝ়āĻŽ |
|---|---|---|
| Dispatchers.Main | UI āĻাāĻেāϰ āĻāύ্āϝ | Main Thread-āĻ āϰাāύ āĻāϰে |
| Dispatchers.IO | āύেāĻāĻāϝ়াāϰ্āĻ/āĻĄাāĻাāĻŦেāϏ | āĻāϞাāĻĻা āĻĨ্āϰেāĻĄে āϰাāύ āĻāϰে |
| Dispatchers.Default | CPU-āĻিāϤ্āϤিāĻ āĻাāĻ | CPU āĻোāϰ āĻ āύুāϝাāϝ়ী āĻĨ্āϰেāĻĄ āϤৈāϰি āĻāϰে |
| Dispatchers.Unconfined | āĻāĻেāϰ āĻĨ্āϰেāĻĄ āϧāϰে āϰাāĻে | āĻāĻেāϰ āĻĨ্āϰেāĻĄে āĻļুāϰু āĻšāϝ়, āĻĒāϰে āĻĒāϰিāĻŦāϰ্āϤāύ āĻšāϤে āĻĒাāϰে |
| newSingleThreadContext | āύিāϰ্āĻĻিāώ্āĻ āĻāĻ āĻĨ্āϰেāĻĄে āĻাāĻ āĻāϰāϤে | āĻāĻāĻি āύāϤুāύ āĻĨ্āϰেāĻĄ āϤৈāϰি āĻāϰে |
đ¯ Dispatcher āĻāĻāύ āĻāĻāĻĻāĻŽ āϏāĻšāĻ āϞাāĻāĻে! đ
āĻāĻāύ āϤুāĻŽি āĻোāύ Dispatcher āĻোāĻĨাāϝ় āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻšāĻŦে āϤা āĻŦুāĻāϤে āĻĒেāϰেāĻো! đ
āϝāĻĻি āĻোāύো āĻĒ্āϰāĻļ্āύ āĻĨাāĻে, āĻāĻŽাāĻে āĻিāĻ্āĻাāϏা āĻāϰো! đĨ
Comments
Post a Comment