🚀 Dispatcher in Kotlin: āϏāĻšāϜ āĻ­াāώাāϝ় āĻŦ্āϝাāĻ–্āϝা

 

🚀 Dispatcher in Kotlin: āϏāĻšāϜ āĻ­াāώাāϝ় āĻŦ্āϝাāĻ–্āϝা

Dispatcher āĻšāϞ āĻāĻ•āϟি āύিāϰ্āĻĻেāĻļāĻ•, āϝা āĻ•োāϟāϞিāύেāϰ Coroutine āĻ—ুāϞোāĻ•ে āĻŦāϞে āĻĻেāϝ় āĻ•োāύ āĻĨ্āϰেāĻĄ āĻŦা āĻĨ্āϰেāĻĄāĻĒুāϞে āϰাāύ āĻ•āϰāϤে āĻšāĻŦে। āĻāϟি āĻŽুāϞāϤ āĻ•াāϜেāϰ āϧāϰāύ āĻ…āύুāϝাāϝ়ী āĻ িāĻ• āĻ•āϰে āĻĻেāϝ়, āĻ•াāϜāϟি CPU-āĻ­িāϤ্āϤিāĻ• āĻšāĻŦে āύাāĻ•ি I/O-āĻ­িāϤ্āϤিāĻ•!


đŸŽ¯ Dispatcher āĻ•েāύ āĻĻāϰāĻ•াāϰ?

āϤুāĻŽি āĻ•ি āϚাāχāĻŦে āϝে āύেāϟāĻ“āϝ়াāϰ্āĻ• āĻ•āϞ āĻŦা āĻĄাāϟাāĻŦেāϏ āĻ…āĻĒাāϰেāĻļāύ CPU-āϤে āĻŦেāĻļি āϞোāĻĄ āĻĻিāĻ•? 🤔
āĻāĻŦং āϤুāĻŽি āĻ•ি āϚাāĻ“ āĻ—াāĻŖিāϤিāĻ• āĻšিāϏাāĻŦ āĻāĻ•āχ āĻĨ্āϰেāĻĄে āϚāϞুāĻ• āϝেāĻ–াāύে UI āϰাāύ āĻ•āϰে? āύা! 😅

Dispatcher āĻāχ āϏāĻŽāϏ্āϝাāϰ āϏāĻŽাāϧাāύ āĻ•āϰে:

  • 🏃 CPU āĻ•াāϜে āφāϞাāĻĻা āĻĨ্āϰেāĻĄāĻĒুāϞ āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰে
  • 🌍 I/O (āύেāϟāĻ“āϝ়াāϰ্āĻ•, āĻĢাāχāϞ āϏিāϏ্āϟেāĻŽ)-āĻāϰ āϜāύ্āϝ āφāϞাāĻĻা āĻĨ্āϰেāĻĄ āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰে
  • 📲 UI āĻāϰ āĻ•াāϜ āĻļুāϧুāĻŽাāϤ্āϰ Main āĻĨ্āϰেāĻĄে āϰাāĻ–āϤে āϏাāĻšাāϝ্āϝ āĻ•āϰে

đŸŽ¯ Dispatcher-āĻāϰ āϧāϰāύāϏāĻŽূāĻš

1️⃣ Dispatchers.MainUI āĻ•াāϜেāϰ āϜāύ্āϝ

📌 āϝāĻ–āύ āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰāĻŦো?

  • 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.IOI/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.DefaultHeavy 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

Popular posts from this blog

AI (Artificial Intelligence) āϏāĻšāϜāĻ­াāĻŦে āĻŦোāĻাāϰ āϜāύ্āϝ āĻāĻ•āĻĻāĻŽ āĻŽāϏ্āϤিāώ্āĻ•-āĻŦাāύ্āϧāĻŦ āĻŦ্āϝাāĻ–্āϝা 🧠🤖

🧠 Regex āĻ•ী?

Kotlin-āĻ āĻ­েāϰিāϝ়েāĻŦāϞ āϘোāώāĻŖা āĻ•āϰাāϰ āĻĻুāχ āωāĻĒাāϝ়