đ§ āĻŽāϏ্āϤিāώ্āĻ-āĻŦাāύ্āϧāĻŦ āĻāĻĒাāϝ়ে āĻোāĻāϞিāύেāϰ āĻ ্āϝাāϏিāύāĻ্āϰোāύাāϏ āĻĒ্āϰোāĻ্āϰাāĻŽিং đ
đ§ āĻŽāϏ্āϤিāώ্āĻ-āĻŦাāύ্āϧāĻŦ āĻāĻĒাāϝ়ে āĻোāĻāϞিāύেāϰ āĻ ্āϝাāϏিāύāĻ্āϰোāύাāϏ āĻĒ্āϰোāĻ্āϰাāĻŽিং đ
āϤুāĻŽি āĻি āĻāĻāύāĻ āĻāϞ্āĻĒāύা āĻāϰেāĻ, āϰাāύ্āύা āĻāϰাāϰ āϏāĻŽāϝ় āϝāĻĻি āĻāĻāĻŦাāϰে āĻļুāϧু āĻāĻāĻাāĻ āĻাāĻ āĻāϰāϤে āĻĒাāϰāϤে? āϝেāĻŽāύ, āĻāĻে āϏāĻŦāĻি āĻাāĻা āĻļেāώ āύা āĻšāĻāϝ়া āĻĒāϰ্āϝāύ্āϤ āĻুāϞাāϝ় āĻাāϤ āĻŦāϏাāϤে āĻĒাāϰāϤে āύা! āĻāϤে āĻāϤ āϏāĻŽāϝ় āύāώ্āĻ āĻšāϤো, āϤাāĻ āύা? đ¤¯
āĻ িāĻ āϤেāĻŽāύāĻ, āϝāĻĻি āĻāĻŽাāĻĻেāϰ āĻĒ্āϰোāĻ্āϰাāĻŽিংāĻ āĻāĻāϏাāĻĨে āĻেāĻŦāϞ āĻāĻāĻা āĻাāĻ āĻāϰāϤে āĻĒাāϰāϤ, āϤাāĻšāϞে āĻŦāĻĄ় āĻŦāĻĄ় āĻ ্āϝাāĻĒ āĻŦা āĻāϝ়েāĻŦāϏাāĻāĻ āĻুāĻŦ āϧীāϰ āĻāϤিāϰ āĻšāϝ়ে āϝেāϤ। āĻāĻাāĻ āϏāĻŽাāϧাāύ āĻāϰে 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
Post a Comment