如何创建可处理海量数据的QTreeView并实现动态加载卸载

问题背景 #

需将包含6万+行且持续新增的磁盘文件数据加载到QTreeView，尝试线程加载因QAbstractItemModel非线程安全失败，现有懒加载子类仍导致滚动卡顿，希望通过fetchMore()和canFetchMore()实现仅加载可见数据、自动释放不可见数据，避免全量加载到内存。

核心解决方案 #

1. 利用canFetchMore()和fetchMore()实现按需加载 #

这两个函数是Qt动态加载的核心接口：

• canFetchMore()：告知视图是否存在未加载的数据
• fetchMore()：触发数据加载逻辑，需在后台线程执行磁盘IO与数据解析，再通过信号槽通知模型在UI线程更新视图，避免阻塞

2. 后台线程处理IO与解析 #

模型不直接操作磁盘，由独立线程负责文件读取、数据解析，完成后通过信号将数据传递给模型，模型调用beginInsertRows()/endInsertRows()安全更新视图。

3. 滚动触发内存清理 #

监听QTreeView滚动事件，记录当前可见行范围，清理范围外的数据（保留上下缓冲行，避免频繁加载），控制内存占用。

修改后的完整代码 #

treeview.h #

#include <QAbstractItemModel>
#include <QTreeView>
#include <QThread>
#include <QElapsedTimer>
#include <QShortcut>
#include <QHash>

// 后台数据加载线程
class DataLoaderThread : public QThread
{
    Q_OBJECT
public:
    explicit DataLoaderThread(qint64 startRow, qint64 fetchCount, QObject *parent = nullptr)
        : QThread(parent), m_startRow(startRow), m_fetchCount(fetchCount) {}

    void run() override {
        // 替换为真实文件读取/解析逻辑
        QVector<QStringList> fetchedData;
        for (qint64 i = m_startRow; i < m_startRow + m_fetchCount; ++i) {
            QStringList row;
            QString str = QString::number(i);
            for (int col = 0; col < 4; ++col) {
                row << str;
            }
            fetchedData.append(row);
        }
        emit dataLoaded(fetchedData, m_startRow);
    }

signals:
    void dataLoaded(const QVector<QStringList>& data, qint64 startRow);

private:
    qint64 m_startRow;
    qint64 m_fetchCount;
};

// 动态加载模型
class LazyLoadingModel : public QAbstractItemModel
{
    Q_OBJECT
public:
    explicit LazyLoadingModel(qint64 totalRows, QObject *parent = nullptr)
        : QAbstractItemModel(parent), m_totalRows(totalRows), m_fetchBatchSize(200) {}

    int rowCount(const QModelIndex &parent = QModelIndex()) const override {
        // 返回总行数，让视图知晓整体数据规模
        return m_totalRows;
    }

    int columnCount(const QModelIndex &parent = QModelIndex()) const override {
        return m_columns.count();
    }

    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override {
        if (!index.isValid())
            return QVariant();

        int row = index.row();
        int column = index.column();

        if (column >= m_columns.count())
            return QVariant();

        // 未加载时返回占位符（可选）
        if (!m_loadedData.contains(row)) {
            return "Loading...";
        }

        if (role == Qt::DisplayRole) {
            return m_loadedData[row][column];
        }

        return QVariant();
    }

    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override {
        if (!parent.isValid())
            return createIndex(row, column);
        else
            return QModelIndex();
    }

    QModelIndex parent(const QModelIndex &index) const override {
        return QModelIndex();
    }

    bool canFetchMore(const QModelIndex &parent) const override {
        if (parent.isValid())
            return false;
        // 已加载行数小于总行数时允许加载
        return m_loadedData.size() < m_totalRows;
    }

    void fetchMore(const QModelIndex &parent) override {
        if (parent.isValid())
            return;

        qint64 currentLoaded = m_loadedData.size();
        qint64 fetchCount = qMin(m_fetchBatchSize, m_totalRows - currentLoaded);

        // 启动后台线程加载数据
        DataLoaderThread* loader = new DataLoaderThread(currentLoaded, fetchCount, this);
        connect(loader, &DataLoaderThread::dataLoaded, this, &LazyLoadingModel::onDataLoaded);
        connect(loader, &QThread::finished, loader, &QObject::deleteLater);
        loader->start();
    }

    void setColumns(const QStringList &columns) {
        m_columns = columns;
    }

    // 清理不可见数据，保留可见范围±缓冲行
    void cleanupUnvisibleData(int firstVisibleRow, int lastVisibleRow) {
        const int buffer = 50;
        int keepStart = qMax(0, firstVisibleRow - buffer);
        int keepEnd = qMin(static_cast<int>(m_totalRows) - 1, lastVisibleRow + buffer);

        QList<int> rowsToRemove;
        for (int row : m_loadedData.keys()) {
            if (row < keepStart || row > keepEnd) {
                rowsToRemove.append(row);
            }
        }

        if (!rowsToRemove.isEmpty()) {
            beginResetModel();
            for (int row : rowsToRemove) {
                m_loadedData.remove(row);
            }
            endResetModel();
        }
    }

private slots:
    void onDataLoaded(const QVector<QStringList>& data, qint64 startRow) {
        beginInsertRows(QModelIndex(), startRow, startRow + data.size() - 1);
        for (qint64 i = 0; i < data.size(); ++i) {
            m_loadedData.insert(startRow + i, data[i]);
        }
        endInsertRows();
    }

private:
    QStringList m_columns;
    qint64 m_totalRows; // 预先获取的文件总行数
    int m_fetchBatchSize; // 每次加载的行数
    QHash<int, QStringList> m_loadedData; // 存储已加载行，key为行号
};

// 自定义TreeView，监听滚动触发内存清理
class TreeView : public QTreeView {
    Q_OBJECT
public:
    explicit TreeView(qint64 totalRows, QWidget* parent = 0) : QTreeView(parent) {
        m_model = new LazyLoadingModel(totalRows, this);
        setModel(m_model);
        m_model->setColumns({ "Column 0", "Column 1", "Column 2", "Column 3" });

        // 监听滚动事件，触发数据清理
        connect(this, &QTreeView::verticalScrollBarValueChanged, this, &TreeView::onScroll);
    }

private slots:
    void onScroll() {
        QModelIndex firstVisible = indexAt(viewport()->rect().topLeft());
        QModelIndex lastVisible = indexAt(viewport()->rect().bottomRight());

        if (!firstVisible.isValid() || !lastVisible.isValid())
            return;

        static_cast<LazyLoadingModel*>(model())->cleanupUnvisibleData(firstVisible.row(), lastVisible.row());
    }

private:
    LazyLoadingModel* m_model;
};

// 主窗口
class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = nullptr)
        : QMainWindow(parent)
    {
        QWidget* centralWidget = new QWidget(this);
        setCentralWidget(centralWidget);
        QGridLayout* layout = new QGridLayout(centralWidget);
        
        // 实际场景需从文件获取真实总行数
        auto treeView = new TreeView(60000, this);
        layout->addWidget(treeView);
      
        QShortcut *shortcut = new QShortcut(QKeySequence(Qt::Key_F2), this);
        connect(shortcut, &QShortcut::activated, [=] {
            qDebug() << "Total rows: " << treeView->model()->rowCount();
        });
    }
};

关键说明 #

• 预获取总行数：需提前扫描文件获取总行数（例如统计换行符数量），确保模型返回正确的rowCount()，让视图知晓整体数据规模。
• 后台线程隔离：磁盘IO与数据解析完全在后台线程执行，避免阻塞UI线程，保证界面流畅。
• 内存缓冲策略：清理不可见数据时保留上下50行缓冲，减少滚动时的频繁加载，平衡内存占用与流畅度。
• 自动触发加载：QTreeView会在滚动到已加载数据边缘时自动调用fetchMore()，无需手动触发。

内容的提问来源于stack exchange，提问作者Cesar