🧠 āĻŽāϏ্āϤিāώ্āĻ•-āĻŦাāύ্āϧāĻŦ āωāĻĒাāϝ়ে āĻ•োāϟāϞিāύেāϰ āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻĒ্āϰোāĻ—্āϰাāĻŽিং 🚀

 

🧠 āĻŽāϏ্āϤিāώ্āĻ•-āĻŦাāύ্āϧāĻŦ āωāĻĒাāϝ়ে āĻ•োāϟāϞিāύেāϰ āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻĒ্āϰোāĻ—্āϰাāĻŽিং 🚀

āϤুāĻŽি āĻ•ি āĻ•āĻ–āύāĻ“ āĻ•āϞ্āĻĒāύা āĻ•āϰেāĻ›, āϰাāύ্āύা āĻ•āϰাāϰ āϏāĻŽāϝ় āϝāĻĻি āĻāĻ•āĻŦাāϰে āĻļুāϧু āĻāĻ•āϟাāχ āĻ•াāϜ āĻ•āϰāϤে āĻĒাāϰāϤে? āϝেāĻŽāύ, āφāĻ—ে āϏāĻŦāϜি āĻ•াāϟা āĻļেāώ āύা āĻšāĻ“āϝ়া āĻĒāϰ্āϝāύ্āϤ āϚুāϞাāϝ় āĻ­াāϤ āĻŦāϏাāϤে āĻĒাāϰāϤে āύা! āĻāϤে āĻ•āϤ āϏāĻŽāϝ় āύāώ্āϟ āĻšāϤো, āϤাāχ āύা? đŸ¤¯

āĻ িāĻ• āϤেāĻŽāύāχ, āϝāĻĻি āφāĻŽাāĻĻেāϰ āĻĒ্āϰোāĻ—্āϰাāĻŽিংāĻ“ āĻāĻ•āϏাāĻĨে āĻ•েāĻŦāϞ āĻāĻ•āϟা āĻ•াāϜ āĻ•āϰāϤে āĻĒাāϰāϤ, āϤাāĻšāϞে āĻŦāĻĄ় āĻŦāĻĄ় āĻ…্āϝাāĻĒ āĻŦা āĻ“āϝ়েāĻŦāϏাāχāϟ āĻ–ুāĻŦ āϧীāϰ āĻ—āϤিāϰ āĻšāϝ়ে āϝেāϤ। āĻāϟাāχ āϏāĻŽাāϧাāύ āĻ•āϰে Asynchronous Programming! đŸŽ¯


🎭 Synchronous vs Asynchronous Programming

Synchronous (āϏিāύāĻ•্āϰোāύাāϏ) - āĻāĻ• āϞাāχāύে āĻ•াāϜ āĻ•āϰা đŸšļ‍♂️

āϏিāύāĻ•্āϰোāύাāϏ āĻĒ্āϰোāĻ—্āϰাāĻŽিং āĻŽাāύে āĻšāϚ্āĻ›ে, āĻāĻ• āϞাāχāύে āĻ•াāϜ āϏāĻŽ্āĻĒāύ্āύ āĻšāĻ“āϝ়া āĻĒāϰ্āϝāύ্āϤ āĻĒāϰেāϰ āĻ•াāϜ āĻ…āĻĒেāĻ•্āώা āĻ•āϰāĻŦে।

fun main() {
    println("☕ āϚা āĻŦাāύাāύো āĻļুāϰু...")
    Thread.sleep(3000) // ā§Š āϏেāĻ•েāύ্āĻĄ āĻ…āĻĒেāĻ•্āώা āĻ•āϰো
    println("đŸĩ āϚা āϤৈāϰি!")
    println("📖 āĻāĻ–āύ āĻŦāχ āĻĒāĻĄ়া āĻļুāϰু!")
}

🕒 āĻāĻ–াāύে ā§Š āϏেāĻ•েāύ্āĻĄেāϰ āϜāύ্āϝ āĻĒুāϰো āĻĒ্āϰোāĻ—্āϰাāĻŽ āφāϟāĻ•ে āĻĨাāĻ•āĻŦে! 😓


Asynchronous (āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ) - āĻāĻ•াāϧিāĻ• āĻ•াāϜ āĻāĻ•āϏাāĻĨে 🚀

āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻĒ্āϰোāĻ—্āϰাāĻŽিং āφāĻŽাāĻĻেāϰāĻ•ে āĻāĻ•াāϧিāĻ• āĻ•াāϜ āĻāĻ•āϏাāĻĨে āϚাāϞাāύোāϰ āϏুāϝোāĻ— āĻĻেāϝ়, āϝেāύ āϏāĻŽāϝ় āĻ…āĻĒāϚāϝ় āύা āĻšāϝ়।

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(3000)
        println("đŸĩ āϚা āϤৈāϰি!")
    }
    println("📖 āĻŦāχ āĻĒāĻĄ়া āĻļুāϰু!")
}

🎉 āĻāĻ–āύ "📖 āĻŦāχ āĻĒāĻĄ়া āĻļুāϰু!" āφāĻ—ে āĻĒ্āϰিāύ্āϟ āĻšāĻŦে, āϤাāϰāĻĒāϰ "đŸĩ āϚা āϤৈāϰি!" āĻ•াāϰāĻŖ delay() āĻŽূāϞ āĻĨ্āϰেāĻĄ āĻŦ্āϞāĻ• āύা āĻ•āϰে āφāϞাāĻĻাāĻ­াāĻŦে āϚāϞāĻŦে।


đŸŽ¯ Kotlin Coroutines: āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻ•āϰাāϰ āĻĒ্āϰāϧাāύ āĻ…āϏ্āϤ্āϰ đŸ”Ĩ

āĻ•োāϟāϞিāύে āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻ•াāϜেāϰ āϜāύ্āϝ Coroutines āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰা āĻšāϝ়। āĻāϟি āϞাāχāϟāĻ“āϝ়েāϟ āĻĨ্āϰেāĻĄেāϰ āĻŽāϤো āĻ•াāϜ āĻ•āϰে।

🔹 Coroutine Scope

āĻāĻ•āϟি coroutine āϚাāϞাāϤে runBlocking {} āĻŦা GlobalScope.launch {} āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰা āϝাāϝ়।

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("👉 āĻ•াāϜ āĻļুāϰু!")
    launch {
        delay(2000)
        println("🔄 āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻ•াāϜ āϚāϞāĻ›ে...")
    }
    println("✅ āĻ…āύ্āϝ āĻ•াāϜ āϚāϞāϤে āĻĨাāĻ•ুāĻ•...")
}

đŸŽ¯ āĻāĻ–াāύে "✅ āĻ…āύ্āϝ āĻ•াāϜ āϚāϞāϤে āĻĨাāĻ•ুāĻ•..." āφāĻ—ে āĻĒ্āϰিāύ্āϟ āĻšāĻŦে, āĻ•াāϰāĻŖ launch āφāϞাāĻĻাāĻ­াāĻŦে āϚāϞāĻŦে।


🔄 Coroutines-āĻāϰ āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āĻĢাংāĻļāύ

āĻĢাংāĻļāύ āĻ•াāϜ
launch {} āύāϤুāύ coroutine āĻļুāϰু āĻ•āϰে (āĻĢাāϝ়াāϰ-āĻ…্āϝাāύ্āĻĄ-āĻĢāϰāĻ—েāϟ)
async {} āύāϤুāύ coroutine āĻļুāϰু āĻ•āϰে āĻāĻŦং āĻĢāϞাāĻĢāϞ āϰিāϟাāϰ্āύ āĻ•āϰে
delay(ms) āύিāϰ্āĻĻিāώ্āϟ āϏāĻŽāϝ়েāϰ āϜāύ্āϝ āĻŦ্āϞāĻ• āύা āĻ•āϰে āĻ…āĻĒেāĻ•্āώা āĻ•āϰে
runBlocking {} main thread āĻŦ্āϞāĻ• āĻ•āϰে coroutine āϚাāϞাāϝ়
withContext {} āύিāϰ্āĻĻিāώ্āϟ āĻĨ্āϰেāĻĄ āĻŦা dispatcher-āĻ āϏুāχāϚ āĻ•āϰে

💡 Async & Await: āϰেāϜাāϞ্āϟ āĻĢেāϰāϤ āĻĒেāϤে āϚাāχāϞে

āϝāĻĻি āφāĻŽāϰা āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻ•াāϜেāϰ āϰেāϜাāϞ্āϟ āĻĢেāϰāϤ āĻĒেāϤে āϚাāχ, āϤাāĻšāϞে async āĻāĻŦং await() āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰāĻŦ।

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result1 = async { heavyTask(1) }
    val result2 = async { heavyTask(2) }

    println("🔹 āĻĢāϞাāĻĢāϞ: ${result1.await()} + ${result2.await()} = ${result1.await() + result2.await()}")
}

suspend fun heavyTask(num: Int): Int {
    delay(2000)
    println("✅ Task $num āĻļেāώ āĻšāϝ়েāĻ›ে!")
    return num * 10
}

🔄 async() āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰে āφāĻŽāϰা heavyTask() āĻĻুāϟো āĻāĻ•āϏাāĻĨে āϚাāϞাāϚ্āĻ›ি, āĻĢāϞে āϏāĻŽāϝ় āĻ•āĻŽ āϞাāĻ—āĻŦে!


🚀 Dispatcher: CPU āĻŦা I/O āϟাāϏ্āĻ•েāϰ āϜāύ্āϝ āĻ…āĻĒāϟিāĻŽাāχāϜেāĻļāύ

Coroutine Dispatcher āĻŦāϞে āĻĻেāϝ়, āĻ•োāύ āĻĨ্āϰেāĻĄে coroutine āϚāϞāĻŦে।

Dispatcher āĻŦ্āϝাāĻ–্āϝা
Dispatchers.Default CPU-intensive āĻ•াāϜেāϰ āϜāύ্āϝ
Dispatchers.IO āύেāϟāĻ“āϝ়াāϰ্āĻ• āĻŦা āĻĢাāχāϞ āϰিāĻĄিংāϝ়েāϰ āϜāύ্āϝ
Dispatchers.Main UI āĻ•াāϜেāϰ āϜāύ্āϝ (Android)
Dispatchers.Unconfined āĻĢ্āϰিāĻĄāĻŽ āĻŽোāĻĄ (āϝেāĻ–াāύে āĻĻāϰāĻ•াāϰ āϏেāĻ–াāύে āϚāϞāĻŦে)
launch(Dispatchers.IO) { fetchData() }

đŸŽ¯ Suspend Function: Coroutine-āĻāϰ āϏেāϰা āĻŦāύ্āϧু

delay() āĻŦা network call āĻāϰ āĻŽāϤো āϏāĻŽāϝ়āϏাāĻĒেāĻ•্āώ āĻĢাংāĻļāύāĻ•ে suspend āĻŦাāύাāϤে āĻšāϝ়।

suspend fun fetchData() {
    delay(3000)
    println("🌍 āĻĄাāϟা āϞোāĻĄ āĻšāϝ়েāĻ›ে!")
}

🚀 suspend āĻĢাংāĻļāύ āĻļুāϧু coroutine-āĻāϰ āĻŽāϧ্āϝে āĻĨেāĻ•েāχ āĻ•āϞ āĻ•āϰা āϝাāϝ়।


🛠️ Exception Handling in Coroutines

Coroutine-āĻāϰ āĻŽāϧ্āϝে āϏāĻŽāϏ্āϝা āĻšāϞে try-catch āĻŦা CoroutineExceptionHandler āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰা āϝাāϝ়।

val handler = CoroutineExceptionHandler { _, exception ->
    println("❌ āϤ্āϰুāϟি āϧāϰা āĻĒāĻĄ়েāĻ›ে: $exception")
}

GlobalScope.launch(handler) {
    throw RuntimeException("āĻāχ āϰāĻ•āĻŽ āϏāĻŽāϏ্āϝা āĻšāϤে āĻĒাāϰে!")
}

đŸŽ¯ āĻ•েāύ āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻĒ্āϰোāĻ—্āϰাāĻŽিং āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰāĻŦ?

āĻĻ্āϰুāϤ āĻĒাāϰāĻĢāϰāĻŽ্āϝাāύ্āϏ – āĻāĻ•āϏাāĻĨে āĻāĻ•াāϧিāĻ• āĻ•াāϜ āĻ•āϰāϤে āĻĒাāϰāĻŦে।
UI āĻŦ্āϞāĻ• āĻšāĻŦে āύা – Android āĻ…্āϝাāĻĒে āχāωāϜাāϰ āĻāĻ•্āϏāĻĒেāϰিāϝ়েāύ্āϏ āĻ­াāϞো āĻšāĻŦে।
CPU āĻ“ I/O āϟাāϏ্āĻ• āϏāĻ িāĻ•āĻ­াāĻŦে āĻŦ্āϝāĻŦāϏ্āĻĨাāĻĒāύা āĻ•āϰা āϝাāĻŦে।


🏆 āĻļেāώ āĻ•āĻĨা

  • āϝāĻĻি āĻāĻ•াāϧিāĻ• āĻ•াāϜ āĻāĻ•āϏাāĻĨে āĻ•āϰāϤে āĻšāϝ় -> Coroutines āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰো!
  • āϝāĻĻি async āĻ…āĻĒাāϰেāĻļāύ āĻ•āϰāϤে āĻšāϝ় -> async + await āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰো!
  • āϝāĻĻি UI āĻ•াāϜ āĻ•āϰāϤে āĻšāϝ় -> Dispatchers.Main āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰো!
  • āϝāĻĻি āϏāĻŽāϏ্āϝা āĻš্āϝাāύ্āĻĄেāϞ āĻ•āϰāϤে āĻšāϝ় -> CoroutineExceptionHandler āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰো!

āĻ…্āϝাāϏিāύāĻ•্āϰোāύাāϏ āĻĒ্āϰোāĻ—্āϰাāĻŽিং āĻŦোāĻা āĻŽাāύে 🚀 āĻĒাāϰāĻĢāϰāĻŽ্āϝাāύ্āϏ āĻ…āĻĒ্āϟিāĻŽাāχāϜ āĻ•āϰা āĻāĻŦং āĻ­āĻŦিāώ্āϝāϤেāϰ āωāύ্āύāϤ āϏāĻĢāϟāĻ“āϝ়্āϝাāϰ āϤৈāϰিāϰ āĻĒāĻĨে āĻāĻ—িāϝ়ে āϝাāĻ“āϝ়া! 💡đŸ”Ĩ


āϤুāĻŽি āϝāĻĻি āφāϰāĻ“ āĻ—āĻ­ীāϰে āĻļিāĻ–āϤে āϚাāĻ“, āϤাāĻšāϞে āϜাāύিāĻ“! 😊🚀

Comments

Popular posts from this blog

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

🧠 Regex āĻ•ী?

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