# Qt多线程编程全面指南

Qt提供了强大的多线程支持，使开发者能够轻松构建高效的并发应用程序。以下是Qt多线程的核心内容：

## 1. Qt多线程基础

### 线程管理类
- **QThread** - 线程类，提供线程管理功能
- **QRunnable** - 可运行任务基类
- **QThreadPool** - 线程池管理

### 线程安全类
- **QMutex** - 互斥锁
- **QReadWriteLock** - 读写锁
- **QSemaphore** - 信号量
- **QWaitCondition** - 条件变量

## 2. 使用QThread创建线程

### 方法一：继承QThread（传统方式）
```cpp
class WorkerThread : public QThread {
    Q_OBJECT
protected:
    void run() override {
        // 线程执行代码
        emit resultReady(result);
    }
signals:
    void resultReady(const QString &result);
};

// 使用
WorkerThread *thread = new WorkerThread;
connect(thread, &WorkerThread::resultReady, this, &Receiver::handleResult);
connect(thread, &WorkerThread::finished, thread, &QObject::deleteLater);
thread->start();
```

### 方法二：moveToThread（推荐方式）
```cpp
class Worker : public QObject {
    Q_OBJECT
public slots:
    void doWork() {
        // 耗时操作
        emit resultReady(result);
    }
signals:
    void resultReady(const QString &result);
};

// 使用
QThread *thread = new QThread;
Worker *worker = new Worker;
worker->moveToThread(thread);
connect(thread, &QThread::started, worker, &Worker::doWork);
connect(worker, &Worker::resultReady, this, &Receiver::handleResult);
connect(thread, &QThread::finished, worker, &QObject::deleteLater);
connect(thread, &QThread::finished, thread, &QObject::deleteLater);
thread->start();
```

## 3. 使用QRunnable和线程池

```cpp
class Task : public QRunnable {
    void run() override {
        // 任务执行代码
    }
};

// 使用线程池
QThreadPool::globalInstance()->start(new Task);
```

## 4. 线程同步机制

### QMutex使用
```cpp
QMutex mutex;
int counter = 0;

void increment() {
    QMutexLocker locker(&mutex); // 自动解锁
    counter++;
}
```

### QReadWriteLock使用
```cpp
QReadWriteLock lock;
QString data;

void readData() {
    QReadLocker locker(&lock);
    qDebug() << data;
}

void writeData(const QString &newData) {
    QWriteLocker locker(&lock);
    data = newData;
}
```

### QWaitCondition使用
```cpp
QMutex mutex;
QWaitCondition condition;
bool dataReady = false;

// 生产者
void produce() {
    QMutexLocker locker(&mutex);
    // 生产数据
    dataReady = true;
    condition.wakeAll();
}

// 消费者
void consume() {
    QMutexLocker locker(&mutex);
    while (!dataReady) {
        condition.wait(&mutex);
    }
    // 消费数据
}
```

## 5. 线程间通信

### 信号槽机制（自动跨线程）
```cpp
// 线程安全方式连接（自动排队）
connect(worker, &Worker::resultReady, 
        receiver, &Receiver::handleResult, 
        Qt::QueuedConnection);
```

### 使用QMetaObject::invokeMethod
```cpp
QMetaObject::invokeMethod(receiver, "handleResult", 
                         Qt::QueuedConnection,
                         Q_ARG(QString, result));
```

## 6. 并发编程（QtConcurrent）

### 基本用法
```cpp
#include <QtConcurrent>

// 并行映射
QList<int> list = {1, 2, 3, 4};
QFuture<void> future = QtConcurrent::map(list, [](int &x) {
    x *= 2;
});
future.waitForFinished();

// 并行过滤
QFuture<int> result = QtConcurrent::filtered(list, [](int x) {
    return x > 2;
});
```

### 高级用法
```cpp
// 带进度报告的并行处理
QFutureWatcher<void> watcher;
connect(&watcher, &QFutureWatcher<void>::progressRangeChanged,
        [](int min, int max) { qDebug() << min << max; });
connect(&watcher, &QFutureWatcher<void>::progressValueChanged,
        [](int value) { qDebug() << "Progress:" << value; });

QFuture<void> future = QtConcurrent::map(list, heavyFunction);
watcher.setFuture(future);
```

## 7. 最佳实践

1. **避免直接继承QThread**（推荐使用moveToThread方式）
2. **不要跨线程操作GUI**（所有UI操作应在主线程）
3. **合理使用线程同步**（避免死锁）
4. **注意对象生命周期**（使用deleteLater管理线程对象）
5. **优先使用QtConcurrent**简化并行任务

## 8. 调试技巧

- 使用`QThread::currentThreadId()`获取线程ID
- 通过`QCoreApplication::instance()->thread()`获取主线程
- 使用`Q_ASSERT_X(QThread::currentThread() == thread(), ...)`验证线程

## 9. 性能考虑

1. **线程创建开销**：频繁创建销毁线程影响性能，使用线程池
2. **锁粒度**：尽量减小锁的范围
3. **无锁设计**：考虑使用原子操作或不可变数据
4. **CPU亲和性**：QThread::setAffinity（特定平台支持）

Qt的多线程框架既提供了底层控制（QThread），也提供了高级抽象（QtConcurrent），开发者可以根据需求选择合适的抽象层次。正确使用多线程可以显著提升应用程序的响应性和性能。