抽象异步任务（AsyncTask）

抽象异步任务（AsyncTask）是一种常用于执行后台操作并在任务完成后更新主线程的机制。它的目标是简化线程管理和任务调度，通常用于耗时操作，比如网络请求、文件处理等，避免阻塞主线程。通过使用 AsyncTask，我们可以在后台线程执行任务，执行完毕后回到主线程处理结果。

在多线程编程中，异步任务（AsyncTask）的关键是如何管理线程池、后台任务的执行、进度更新以及任务完成后的回调。为了实现高效的异步任务，我们通常需要抽象出任务的执行流程、线程同步以及错误处理等。

以下是对抽象异步任务 AsyncTask 的实现和使用方式的详细介绍。

1. 异步任务的核心概念

AsyncTask 模型包含几个重要的操作步骤，通常包括以下内容：

doInBackground()：在后台线程执行任务的主要部分，处理耗时操作（如网络请求、数据库操作等）。
onProgressUpdate()：用于更新任务进度，通常在主线程中执行。
onPostExecute()：任务完成后回调的操作，通常在主线程中处理结果。

1.1 流程概述

创建异步任务对象，传入相关参数。
执行 doInBackground()，在后台线程中执行耗时操作。
在任务执行过程中，若需要更新进度，可以调用 publishProgress()，会触发 onProgressUpdate()。
最终，任务完成后，回调 onPostExecute() 处理结果。

1.2 示例任务流程

初始化任务：创建异步任务对象。
执行任务：调用异步任务的 execute() 方法。
进度更新：在任务进行过程中，调用 publishProgress() 更新进度。
任务完成：执行完毕后，调用 onPostExecute() 来处理结果。

2. 使用互斥锁实现线程安全的异步任务

在并发环境中，我们可能需要确保多个线程安全地执行异步任务。为了保证数据的一致性和正确性，可以使用互斥锁（mutex）来保护任务的执行，防止多个线程同时修改共享资源。

以下是使用互斥锁实现的基本异步任务模型，主要用于确保任务调度的线程安全性。

2.1 任务结构体定义

我们定义一个 AsyncTask 结构体来表示异步任务，并使用互斥锁保护任务的执行。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    pthread_t thread;           // 任务执行的线程
    pthread_mutex_t mutex;      // 用于同步的互斥锁
    int is_completed;           // 任务是否完成
    void (*doInBackground)(void*); // 后台任务
    void (*onPostExecute)(void*);  // 任务完成后的回调
} AsyncTask;

2.2 初始化和执行任务

我们需要创建一个函数来初始化和执行异步任务。在初始化时，我们设置互斥锁以确保任务执行的互斥性。

// 初始化异步任务
void initAsyncTask(AsyncTask* task, void (*doInBackground)(void*), void (*onPostExecute)(void*)) {
    task->doInBackground = doInBackground;
    task->onPostExecute = onPostExecute;
    pthread_mutex_init(&task->mutex, NULL);
    task->is_completed = 0;
}

// 执行异步任务
void* executeAsyncTask(void* arg) {
    AsyncTask* task = (AsyncTask*)arg;

    // 执行后台任务
    task->doInBackground(arg);

    // 任务完成后调用回调
    pthread_mutex_lock(&task->mutex);
    task->is_completed = 1;
    pthread_mutex_unlock(&task->mutex);
    task->onPostExecute(arg);
    return NULL;
}

// 启动任务
void startAsyncTask(AsyncTask* task) {
    pthread_create(&task->thread, NULL, executeAsyncTask, task);
}

2.3 示例：任务的具体实现

在后台任务中，我们可以执行各种耗时操作，比如模拟网络请求、文件处理等。回调函数用于在任务完成后处理结果。

void myTaskInBackground(void* arg) {
    // 模拟耗时操作
    printf("Task is running in background...\n");
    sleep(2);  // 模拟耗时操作
}

void myTaskOnPostExecute(void* arg) {
    printf("Task completed!\n");
}

int main() {
    AsyncTask task;
    
    // 初始化任务并设置后台操作和回调
    initAsyncTask(&task, myTaskInBackground, myTaskOnPostExecute);
    
    // 启动任务
    startAsyncTask(&task);
    
    // 等待任务完成
    pthread_join(task.thread, NULL);
    
    return 0;
}

3. 使用线程池管理多个异步任务

当需要执行多个异步任务时，可以使用线程池来优化资源的使用和任务调度。线程池可以减少频繁创建和销毁线程的开销，并提高任务的并发执行能力。

3.1 线程池实现

线程池的核心思想是预先创建一组线程，当任务到来时，线程池会从线程池中分配线程来执行任务。线程池的任务队列会维护待执行的任务，确保线程资源得到合理利用。

3.2 线程池代码示例

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define THREAD_POOL_SIZE 4  // 线程池的大小

typedef struct {
    pthread_t threads[THREAD_POOL_SIZE]; // 线程池中的线程
    pthread_mutex_t mutex;               // 保护任务队列的互斥锁
    int task_count;                       // 任务数量
    void (*taskQueue[])(void*);           // 任务队列
} ThreadPool;

// 启动线程池
void initThreadPool(ThreadPool* pool) {
    pthread_mutex_init(&pool->mutex, NULL);
    pool->task_count = 0;
}

// 添加任务到线程池
void addTaskToThreadPool(ThreadPool* pool, void (*task)(void*)) {
    pthread_mutex_lock(&pool->mutex);
    pool->taskQueue[pool->task_count++] = task;
    pthread_mutex_unlock(&pool->mutex);
}

// 线程池中线程执行任务
void* worker(void* arg) {
    ThreadPool* pool = (ThreadPool*)arg;
    while (1) {
        pthread_mutex_lock(&pool->mutex);
        if (pool->task_count > 0) {
            void (*task)(void*) = pool->taskQueue[--pool->task_count];
            pthread_mutex_unlock(&pool->mutex);
            task(NULL);  // 执行任务
        } else {
            pthread_mutex_unlock(&pool->mutex);
            break;
        }
    }
    return NULL;
}

int main() {
    ThreadPool pool;
    initThreadPool(&pool);
    
    // 向线程池添加任务
    addTaskToThreadPool(&pool, myTaskInBackground);
    
    // 启动线程池中的线程
    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_create(&pool.threads[i], NULL, worker, &pool);
    }
    
    // 等待所有线程完成
    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_join(pool.threads[i], NULL);
    }

    return 0;
}