如何用异步获取的数据填充QTableView？

Question

我想在创建时用一些提取的数据（例如，使用数据库或网络请求）填充QTableView。因为请求需要一些时间-从而阻塞了GUI-我得出的结论是使用另一个线程进行提取。

我当前的设置如下所示（显然已简化）：

class MyTable : public QTableView {
    QFutureWatcher<QAbstractItemModel*>* watcher;

    void init() {
        watcher = new QFutureWatcher<QAbstractItemModel*>();
        connect(watcher, SIGNAL(finished()), this, SLOT(onResult()));
        watcher->setFuture(QtConcurrent::run(...))
    }

    void onResult() {
        setModel(watcher->result());
    }
}

在将对象添加到GUI之后，将调用init（）方法。因为我对C ++ / Qt /多线程还很陌生，所以我想问一下这段代码是否表现出预期的效果，或者是否会遇到某种竞争情况或类似情况。我特别担心onResult（）方法，因为我担心“ setModel”可能不是线程安全的。

Answer 1

如果模型异步加载其数据，则无需子视图。这与视图的行为无关。

Model / View模式的整个目的是使模型与视图组件分离，以增加灵活性和重用性。通过像这样子化视图，就可以再次将它们耦合起来。

我特别担心onResult（）方法，因为我担心“ setModel”可能不是线程安全的。

您是对的，setModel不是线程安全的。QWidget除了主线程外，您不应该接触其他任何线程，请参阅docs。但是，onResult保证在视图所在的线程（应该是主线程）中调用方法。因此，这里没有错。。。

但是，似乎您是在从线程池调用的函数中创建模型。如果您在函数结束时不将模型移至主线程（很可能您没有这样做），则模型将驻留在不运行事件循环的线程中。它将无法接收事件，这只是自找麻烦。通常，应避免QObject在线程之间传递s（如果可能），而仅传递所需的数据结构。

我将从头开始，并通过子类实现整个过程QAbstractTableModel，这是一个完整的最小示例：

#include <QtWidgets>
#include <QtConcurrent>
#include <tuple>

class AsyncTableModel : public QAbstractTableModel{
    Q_OBJECT
    //type used to hold the model's internal data in the variable m_rows
    using RowsList = QList<std::tuple<QString, QString, QString> >;
    //model's data
    RowsList m_rows;
    QFutureWatcher<RowsList>* m_watcher;
public:
    explicit AsyncTableModel(QObject* parent= nullptr):QAbstractTableModel(parent){
        //start loading data in the thread pool as soon as the model is instantiated 
        m_watcher = new QFutureWatcher<RowsList>(this);
        connect(m_watcher, &QFutureWatcher<RowsList>::finished,
                this, &AsyncTableModel::updateData);
        QFuture<RowsList> future = QtConcurrent::run(&AsyncTableModel::retrieveData);
        m_watcher->setFuture(future);
    }
    ~AsyncTableModel() = default;

    //this is a heavy function that returns data you want the model to display
    //this is called in the thread pool using QtConcurrent::run
    static RowsList retrieveData(){
        //the function is heavy that it blocks the calling thread for 2 secs
        QThread::sleep(2);
        RowsList list;
        for(int i=0; i<10; i++){
            list.append(std::make_tuple(QString("A%0").arg(i),
                                        QString("B%0").arg(i),
                                        QString("C%0").arg(i)));
        }
        return list;
    }
    //this is the slot that is called when data is finished loading
    //it resets the model so that it displays new data
    Q_SLOT void updateData(){
        beginResetModel();
        m_rows = m_watcher->future().result();
        endResetModel();
    }

    int rowCount(const QModelIndex &parent) const {
        if(parent.isValid()) return 0;
        return m_rows.size(); 
    }
    int columnCount(const QModelIndex &parent) const {
        if(parent.isValid()) return 0;
        return 3; 
    }

    QVariant data(const QModelIndex &index, int role) const {
        QVariant value= QVariant();
        switch(role){
        case Qt::DisplayRole: case Qt::EditRole:
            switch(index.column()){
            case 0:
                value= std::get<0>(m_rows[index.row()]);
                break;
            case 1:
                value= std::get<1>(m_rows[index.row()]);
                break;
            case 2:
                value= std::get<2>(m_rows[index.row()]);
            }
            break;
        }
        return value;
    }
};

int main(int argc, char* argv[]){
    QApplication a(argc, argv);

    QTableView tv;
    AsyncTableModel model;
    tv.setModel(&model);
    tv.show();


    return a.exec();
}

#include "main.moc"

注意：

上面的示例显示了如何从长时间阻塞线程的函数中将数据异步加载到模型中。执行大量计算的函数就是这种情况。如果您的目标是通过网络加载数据，则应该使用QTcpSocket/中提供的异步API QNetworkAccessManager，在这些情况下根本不需要使用线程池，但是除此之外，所有操作都应该相似。