import kotlinx.coroutines.*
fun main() {
    // 創(chuàng)建協程
    val job = GlobalScope.launch {
        // 協程代碼塊
        delay(1000)
        println("Hello from Coroutine!")
    }
    // 等待協程完成
    runBlocking {
        job.join()
    }
}

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        try {
            delay(1000)
            println("Coroutine completed.")
        } catch (e: CancellationException) {
            println("Coroutine was cancelled.")
        }
    }
    delay(500)
    job.cancel() // 取消協程
    job.join()
}

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        try {
            throw Exception("Something went wrong")
        } catch (e: Exception) {
            println("Exception caught: ${e.message}")
        }
    }
    job.join()
}

launch(Dispatchers.IO) {
    // 在IO線程上執(zhí)行協程代碼，適用于網絡請求和文件操作
}
launch(Dispatchers.Default) {
    // 在默認的線程池上執(zhí)行協程代碼，適用于CPU密集型操作
}

launch {
    val result = withContext(Dispatchers.IO) {
        // 在IO線程上執(zhí)行異步操作
    }
    // 在UI線程處理結果
}

val customDispatcher = Executors.newFixedThreadPool(4).asCoroutineDispatcher()
launch(customDispatcher) {
    // 在自定義調度器上執(zhí)行協程代碼
}

suspend fun fetchUserData(): UserData {
    // 執(zhí)行異步操作，等待數據返回
}

launch {
    val userData = fetchUserData()
    // 處理獲取到的用戶數據
}

launch {
    try {
        val userData = fetchUserData()
        // 處理獲取到的用戶數據
    } catch (e: Exception) {
        // 處理異常情況
    }
}

launch {
    try {
        val userData = fetchUserData()
        // 處理獲取到的用戶數據
    } catch (e: CancellationException) {
        // 協程被取消時的處理
    } catch (e: Exception) {
        // 其他異常情況
    }
}

suspend fun performMultipleTasks() = coroutineScope {
    val result1 = async { fetchFromNetwork() }
    val result2 = async { fetchFromDatabase() }
    val combinedResult = result1.await() + result2.await()
    // 處理并發(fā)任務的結果
}

class MyActivity : AppCompatActivity(), CoroutineScope by CoroutineScope(Dispatchers.Main) {
    // ...
    override fun onDestroy() {
        super.onDestroy()
        cancel() // 取消協程作用域內的所有協程
    }
}

launch {
    // 在協程作用域內啟動協程
    // 該協程將繼承外部作用域的上下文和調度器
}

class MyActivity : AppCompatActivity(), CoroutineScope by CoroutineScope(Dispatchers.Main) {
    // ...
    fun performMultipleTasks() = launch {
        // 在外部作用域的協程內啟動協程
        launch {
            // 在內部作用域的協程內啟動協程
        }
    }
}

runBlocking {
    // 在結構化并發(fā)作用域內啟動協程
    launch {
        // 協程1
    }
    launch {
        // 協程2
    }
    // 等待所有協程完成后繼續(xù)
}

launch {
    val result1 = async { fetchFromNetwork() }
    val result2 = async { fetchFromDatabase() }
    val combinedResult = result1.await() + result2.await()
    // 處理并發(fā)任務的結果
}

launch {
    val dataFromDatabase = async { fetchFromDatabase() }.await()
    val updatedData = async { performNetworkRequest(dataFromDatabase) }.await()
    // 處理順序性操作的結果
}

runBlocking {
    val result = withContext(Dispatchers.IO) {
        val dataFromDatabase = async { fetchFromDatabase() }.await()
        val updatedData = async { performNetworkRequest(dataFromDatabase) }.await()
        // 更多操作...
        updatedData
    }
    // 處理組合多個協程流程的結果
}

runBlocking {
    val result = withContext(Dispatchers.IO) {
        fetchFromDatabaseAsync()
            .then { dataFromDatabase -> performNetworkRequestAsync(dataFromDatabase) }
            .then { updatedData -> performAdditionalOperationAsync(updatedData) }
            .await()
    }
    // 處理異步風格順序性操作的結果
}

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        for (i in 1..5) {
            channel.send(i)
        }
        channel.close()
    }
    launch {
        for (item in channel) {
            println("Received: $item")
        }
    }
}

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val channel = Channel<Unit>()
    val job = launch {
        // 等待特定的信號
        channel.receive()
        println("Coroutine received signal.")
    }
    delay(1000)
    channel.send(Unit) // 發(fā)送信號給協程
    job.join()
}

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val producer: Job = launch {
        val channel = Channel<Int>()
        // 扇出模式
        launch {
            for (i in 1..5) {
                channel.send(i)
            }
            channel.close()
        }
        // 扇入模式
        launch {
            for (item in channel) {
                println("Received: $item")
            }
        }
    }
    producer.join()
}

import kotlinx.coroutines.*
import kotlin.coroutines.CoroutineContext
class MainActivity : AppCompatActivity() {
    private val mainScope = MainScope()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mainScope.launch {
            // 在UI線程中啟動協程
            val result = withContext(Dispatchers.IO) {
                // 執(zhí)行異步操作，例如網絡請求
            }
            updateUI(result)
        }
    }
    override fun onDestroy() {
        super.onDestroy()
        mainScope.cancel() // 取消協程，避免資源泄漏
    }
    private fun updateUI(data: Any) {
        // 更新UI界面
    }
}

class MyViewModel : ViewModel() {
    fun performAsyncTask() {
        viewModelScope.launch {
            // 在UI線程中啟動協程
            val result = withContext(Dispatchers.IO) {
                // 執(zhí)行異步操作，例如網絡請求
            }
            // 更新UI界面
        }
    }
}

class MyViewModel : ViewModel() {
    val dataLiveData: LiveData<ResultType> = liveData {
        val result = fetchData()
        emit(result)
    }
}