用事件隊列解決GUI的操作順序問題（Qt中處理方法）

GUI操作順序問題引發異常：

---

　　有時候我們使用寫GUI程序的時候會遇到這樣的問題：比如在程序中，建立了一個列表的GUI。這個列表是隨着時間不斷更新的，而且操作也會讀取這個列表GUI的內容。

　　如果這個程序是多線程的程序，而且只是除了GUI的線程不操作，只是其他線程操作這個列表GUI，那么這個問題很簡單，只用加互斥鎖就可以了。但如果GUI線程自己本身也要操作這個列表，那么這個問題就很麻煩了。

　　我們可以很容易地想到一種場景，比如GUI線程讀了列表的一些表項（比如選定），此時線程中的某個方法keep了這些表項的指針，然而此時很不幸別的線程有一個請求需要刪除列表中的一些表項，並且這些表項有一些包含在了我們的選定內容里，我們知道幾乎所有的語言操作GUI時都要進入GUI線程里面操作，那么我們剛才選定表項的那個方法會被打斷，然后進入刪除表項方法，在刪除了表項以后再次回到選定表項方法時，我們的選定的表項有一些已經被刪除了，此時我們再進行操作很有可能不符合我們的要求。

　　如果你是用一般是用C#，JAVA這種不用自己管理內存的語言，那還好，只是結果可能不對，但是如果是用C++這種需要我們自己管理內存的來寫，很有可能我們會操作一個被釋放了內存的對象，然后程序崩掉，這樣的情況是我們不想看到的。

 

用事件隊列來解決問題：

---

　　下面用一幅圖來表示如何設計事件隊列：

 

　　當然圖中雖然是只有三種操作，如果你想，你可以設計出更多的操作，比如讀操作，你可以細分為復制表項中的信息和給表項中對應的內容進行操作等。

這樣設計以后，就一定程度上消除了GUI打斷操作的問題（比如我們會再遇到我們上面的那種訪問了一個被析構了的對象問題）。

 

　　在Qt中我們可以這樣寫：（ConnectionView這個對象就是我上面說的那種表項）

class ItemsOpsBase
    {
    public:
        virtual void doOperation(ConnectionView *view) = 0;
        virtual ~ItemsOpsBase() = default;
    };
    
    class DeleteItem : public ItemsOpsBase
    {
    public:
        DeleteItem(qintptr target,qint32 connectionIndex)
            :ItemsOpsBase(), _target(target),_connectionIndex(connectionIndex){ }
        
        void doOperation(ConnectionView *view)override;
        ~DeleteItem() = default;
    private:
        qintptr _target;
        qint32 _connectionIndex;
    };
    
    class UpdatePulse :public ItemsOpsBase
    {
    public:
        UpdatePulse(qintptr descriptor,qint32 currentTime)
            :ItemsOpsBase(), _descriptor(descriptor),_currentTime(currentTime){  }
        
        void doOperation(ConnectionView *view)override;
        ~UpdatePulse() = default;
    private:
        qintptr _descriptor;
        qint32 _currentTime;
    };

class UpdateRemark : public ItemsOpsBase
    {
    public:
        UpdateRemark(qintptr descriptor, const QString &remark)
            : ItemsOpsBase(),_remark(remark),_descriptor(descriptor){  }
        
        void doOperation(ConnectionView *view)override;
        ~UpdateRemark() = default;
    private:
        QString _remark;
        qintptr _descriptor;
    };
    
    class TestConnection : public ItemsOpsBase
    {
    public:
        void doOperation(ConnectionView *view)override;
    };
class TestConnectionProducer : public QThread
    {
    public:
        void run()override;
    };
    
    class CopySelectedItemInformProducer :  public QThread
    {
    public:
        void run()override;
    };
    
    class DisconnectTargetsProducer : public QThread
    {
    public:
        void run()override;
    };
    
    class DeleteItemProducer :public QThread
    {
    public:
        DeleteItemProducer(qintptr target, qint32 connectionIndex)
            : QThread(),_target(target),_connectionIndex(connectionIndex) { }
        void run()override;
    private:
        qintptr _target;
        qint32 _connectionIndex;
    };
    
    class UpdatePulseProducer :public QThread
    {
    public:
        UpdatePulseProducer(qintptr descriptor, qint32 currentTime)
            :QThread(),_descriptor(descriptor),_currentTime(currentTime){  }
    protected:  
        void run()override;
    private:
        qintptr _descriptor;
        qint32 _currentTime;
    };
    
    class UpdateRemarkProducer : public QThread
    {
    public:
        UpdateRemarkProducer(qintptr descriptor, const QString &remark)
            :QThread(),_remark(remark),_descriptor(descriptor){ }
    protected:   
        void run()override;
    private:
        QString _remark;
        qintptr _descriptor;
    };
class ConsumerHelper :public QThread
    {
    public:
        ConsumerHelper(ConnectionView *view)
            :QThread(),_view(view){ }
        ~ConsumerHelper();
    protected:
        void run() override;
    private:
        ConnectionView *_view;
        
        ConsumerHelper(const ConsumerHelper &other) = delete;
        ConsumerHelper(const ConsumerHelper &&other) = delete;
        ConsumerHelper &operator=(const ConsumerHelper &other) = delete;
    };

 

　　互斥鎖以及隊列的代碼：

static QQueue<QSharedPointer<ItemsOpsBase>> &opQueue()
{
       static QQueue<QSharedPointer<ItemsOpsBase>> queue;
       return queue;
}
    
static QSharedPointer<ItemsOpsBase> endOperation;

static QMutex &opQueueLock()
{
       static QMutex mutex;
       return mutex;
}
static QWaitCondition &opQueueIsAvailable()
{
       static QWaitCondition flag;
       return flag;
}

 

　　ConsumerHelper是一個消費者線程，一直監視着隊列的動向，當需要一個某個操作的時候，我們就可以引發一個對象操作的線程，把對應操作加入隊列中（為什么需要開一個線程，是為了方便互斥），比如下面我需要一個刪除操作：

　　刪除操作的代碼：

 void DeleteItem::doOperation(ConnectionView *view)
    {
        qRegisterMetaType<qintptr>("qintptr");
        qRegisterMetaType<TcpConnectionHandler *>("TcpConnectionHandler *");
        QMetaObject::invokeMethod(view, "deleteConnection",Qt::QueuedConnection, Q_ARG(qintptr, _target), Q_ARG(qint32, _connectionIndex));
    }
void DeleteItemProducer::run()
    {
        QSharedPointer<ItemsOpsBase> op = QSharedPointer<ItemsOpsBase>(new DeleteItem(_target,_connectionIndex));
        
        QMutexLocker locker(&opQueueLock());
        opQueue().enqueue(op);
        opQueueIsAvailable().wakeOne();
    }

 

 

消費者線程的代碼：

void ConsumerHelper::run()
    {
        forever
        {
            QSharedPointer<ItemsOpsBase> opPointer;
            
            {
                QMutexLocker locker(&opQueueLock());
                
                if (opQueue().isEmpty())
                    opQueueIsAvailable().wait(&opQueueLock());
                opPointer = opQueue().dequeue();
                
                if (opPointer == endOperation)
                    break;
            }
            {
                if(!opPointer.isNull())
                    opPointer->doOperation(_view);
            }
        }
    } 

    ConsumerHelper::~ConsumerHelper()
    {
        {
            QMutexLocker locker(&opQueueLock());
            while(!opQueue().isEmpty())
                opQueue().dequeue();
            
            opQueue().enqueue(endOperation);
            opQueueIsAvailable().wakeOne();
        }
        
        wait();//注意這里是wait在次線程上的
    }

 

 

　　這個時候我只需要在需要用到刪除操作的地方用：

DeleteItemProducer *deleteItemProducer = new DeleteItemProducer(target,index);
connect(deleteItemProducer, &QThread::finished, deleteItemProducer, &QThread::deleteLater);
deleteItemProducer->start();

 

啟動刪除操作生產者的線程就可以了，我們就把刪除操作加入隊列中，合適的時候，消費者線程會執行這個操作，並且把操作投遞到GUI線程中進行。