Android多线程编程 #

// 创建线程
Thread {
    // 耗时操作
    val result = doWork()
    
    // 更新UI需要在主线程
    runOnUiThread {
        updateUI(result)
    }
}.start()

// 使用线程池
val executor = Executors.newFixedThreadPool(4)
executor.execute {
    // 耗时操作
}

// synchronized
@Synchronized
fun synchronizedMethod() {
    // 同步代码
}

// Lock
val lock = ReentrantLock()
lock.lock()
try {
    // 同步代码
} finally {
    lock.unlock()
}

class MainActivity : AppCompatActivity() {
    
    private val handler = Handler(Looper.getMainLooper())
    
    private val runnable = object : Runnable {
        override fun run() {
            // 更新UI
            updateUI()
            handler.postDelayed(this, 1000)
        }
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 延迟执行
        handler.postDelayed(runnable, 1000)
    }
    
    override fun onDestroy() {
        super.onDestroy()
        handler.removeCallbacks(runnable)
    }
}

class MyHandlerThread : HandlerThread("MyThread") {
    
    private lateinit var handler: Handler
    
    override fun onLooperPrepared() {
        handler = Handler(looper)
    }
    
    fun postTask(task: Runnable) {
        handler.post(task)
    }
}

// 使用
val handlerThread = MyHandlerThread()
handlerThread.start()
handlerThread.postTask {
    // 后台任务
}

class MainActivity : AppCompatActivity() {
    
    private val handler = object : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                1 -> {
                    val data = msg.obj as String
                    updateUI(data)
                }
            }
        }
    }
    
    fun sendMessage() {
        Thread {
            val result = doWork()
            val message = handler.obtainMessage(1, result)
            handler.sendMessage(message)
        }.start()
    }
}

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
}

// GlobalScope（不推荐）
GlobalScope.launch {
    // 协程代码
}

// lifecycleScope（推荐）
lifecycleScope.launch {
    // 协程代码
}

// viewModelScope（推荐）
viewModelScope.launch {
    // 协程代码
}

// launch：启动新协程，不返回结果
lifecycleScope.launch {
    delay(1000)
    println("Hello")
}

// async：启动新协程，返回Deferred
lifecycleScope.launch {
    val deferred = async {
        delay(1000)
        "Result"
    }
    val result = deferred.await()
}

// withContext：切换上下文
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        // IO操作
        fetchData()
    }
    // 更新UI
    updateUI(result)
}

lifecycleScope.launch(Dispatchers.IO) {
    // IO操作
    val data = fetchData()
    
    withContext(Dispatchers.Main) {
        // 更新UI
        updateUI(data)
    }
}

// 自定义作用域
class MyManager {
    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    
    fun doWork() {
        scope.launch {
            // 协程代码
        }
    }
    
    fun cancel() {
        scope.cancel()
    }
}

lifecycleScope.launch {
    try {
        val result = withContext(Dispatchers.IO) {
            fetchData()
        }
        updateUI(result)
    } catch (e: Exception) {
        showError(e.message)
    }
}

// 使用CoroutineExceptionHandler
val handler = CoroutineExceptionHandler { _, exception ->
    Log.e("Coroutine", "Error", exception)
}

lifecycleScope.launch(handler) {
    // 协程代码
}

fun getData(): Flow<Result<Data>> = flow {
    emit(Result.Loading)
    try {
        val data = repository.getData()
        emit(Result.Success(data))
    } catch (e: Exception) {
        emit(Result.Error(e.message))
    }
}

// 使用
lifecycleScope.launch {
    viewModel.getData()
        .flowOn(Dispatchers.IO)
        .collect { result ->
            when (result) {
                is Result.Loading -> showLoading()
                is Result.Success -> showData(result.data)
                is Result.Error -> showError(result.message)
            }
        }
}

// 固定大小线程池
val fixedPool = Executors.newFixedThreadPool(4)

// 缓存线程池
val cachedPool = Executors.newCachedThreadPool()

// 单线程池
val singlePool = Executors.newSingleThreadExecutor()

// 定时线程池
val scheduledPool = Executors.newScheduledThreadPool(2)

// 使用
fixedPool.execute {
    // 任务
}

// 关闭
fixedPool.shutdown()

val executor = ThreadPoolExecutor(
    4,      // 核心线程数
    8,      // 最大线程数
    60L,    // 空闲线程存活时间
    TimeUnit.SECONDS,
    LinkedBlockingQueue(128),
    ThreadFactory { r -> Thread(r, "MyThread") }
)

// 不推荐
Thread {
    val result = doWork()
    runOnUiThread {
        updateUI(result)
    }
}.start()

// 推荐
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        doWork()
    }
    updateUI(result)
}

class MainActivity : AppCompatActivity() {
    
    private var job: Job? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        job = lifecycleScope.launch {
            // 协程代码
        }
    }
    
    override fun onDestroy() {
        super.onDestroy()
        job?.cancel()
    }
}

lifecycleScope.launch {
    // 父协程
    launch {
        // 子协程1
    }
    
    launch {
        // 子协程2
    }
}
// 父协程取消时，子协程也会取消