0

我的 gui 有两个按钮，一个用于启动服务器，另一个用于停止服务器。

Brief:---
一旦服务器启动，在每个新的客户端请求上，我都会创建一个新线程，这将处理与客户端的通信。

Detail:--按下
时start button，我正在创建一个对象“ tcpserverobjectWrapper”，该对象创建另一个对象“ tcpserverobject”，此对象创建一个 Qtcpserver。现在这个 Qtcpserver 正在列出新的连接。当一个新的连接到来时，我创建一个' TcpSocketThreadWrapperObject'对象，它创建一个线程&这个线程处理与客户端的通信。' tcpserverobject' 还保留了创建的新客户端请求对象的列表 ' QList<TcpSocketThreadWrapperObject *> TcpSocketThreadWrapperObjectList;' 。

我能够从 telnet 客户端连接到服务器，它为每个客户端创建新线程并且工作正常。

当stop button按下时，我能够停止服务器和客户端线程。

但我在two problems这里：---
1> 每次客户端向服务器发送一些数据。我得到这种QsocketNotifier. 这是什么 ？

QSocketNotifier: socket notifiers cannot be enabled from another thread
QSocketNotifier: socket notifiers cannot be disabled from another thread

2> 如果我按下 GUI 上的停止按钮，我可以成功停止线程。

STOP command但是，当客户端将“ ”发送到服务器或使用服务器时，如何停止线程并删除为每个客户端创建的对象closes the connection？
我还必须删除在每个客户端请求上创建的以下对象？
客户端请求 --> TcpSocketThreadWrapperObject -- 创建 --> TcpSocketThreadObject -- 创建 --> TcpSocketThreadObject

有人可以建议如何解决上述两个问题吗？对此的回复将不胜感激。

这是代码：---

================= 开始和停止按钮处理程序 =====

void MainWindow::on_actionStop_triggered()
{
    if(b_threadAlreadyStarted)
    {

    /* ------------------ Tcp server object ------------------------*/

        b_threadAlreadyStarted = false;
        delete p_tcpserverobjectWrapper;

    /* ------------------ Tcp server object ------------------------*/

    }

}



void MainWindow::on_actionStart_triggered()
{

    if(!b_threadAlreadyStarted)
    {

    /* ------------------ Tcp server object ------------------------*/

        b_threadAlreadyStarted =true;

        p_tcpserverobjectWrapper = new tcpserverobjectWrapper(this,modelCANalyzer);

        qDebug() << " \n start ";

    /* ------------------ Tcp server object ------------------------*/

    }
}

======== tcpserverobjectWrapper 类 ================

// Main server object wrapper
class tcpserverobjectWrapper : public QObject
{
    Q_OBJECT
public:
    explicit tcpserverobjectWrapper(QMainWindow *ptrWidget, QStandardItemModel *modelCANalyzer, QObject *parent=0);
    ~tcpserverobjectWrapper();

    //Device thread object
    tcpserverobject *m_tcpserverobject;
};



tcpserverobjectWrapper::tcpserverobjectWrapper(QMainWindow *ptrWidget , QStandardItemModel *modelCANalyzer,QObject *parent) :
    QObject(parent)
{
    m_tcpserverobject = new tcpserverobject ;

    //save model
    m_tcpserverobject->modeltable = modelCANalyzer;
    m_tcpserverobject->ptrmainwindow = ptrWidget;


    qDebug() << "\n tcp server thread started";

}

tcpserverobjectWrapper::~tcpserverobjectWrapper()
{

    qDebug() << " \n called delete later on tcpserverobjectWrapper .. !!";

    m_tcpserverobject->deleteLater();   // ---------------------> change it to - delete m_tcpserverobject

    qDebug() << " \n tcp server object successfully quited .. !! ";
}

========== tcpserverobject 对象 ==================

class tcpserverobject : public QObject
{
    Q_OBJECT
public:
    explicit tcpserverobject(QObject *parent = 0);
    ~tcpserverobject();

    /*!
        Pointer to QStandardItemModel to be used inside - canTableView
    */
    QStandardItemModel *modeltable;

    //mainwindow pointer
    QMainWindow *ptrmainwindow;

    // Create list of new -- socket thread wrapper objects
    QList<TcpSocketThreadWrapperObject *> TcpSocketThreadWrapperObjectList;

private:
    QTcpServer *tcpServer;

signals:

public slots:

    void on_newConnection();

};

tcpserverobject::tcpserverobject(QObject *parent) :
    QObject(parent), tcpServer(0)
{
    tcpServer = new QTcpServer;

    // Connect slot of the server
    connect(tcpServer, SIGNAL(newConnection()), this, SLOT(on_newConnection()));

    //lisen on socket
    if (!tcpServer->listen(QHostAddress::LocalHost, SERVER_PORT )) {

        qDebug() << "\n returning from server listning error .. !!! ";

        return;
    }

    qDebug() << "\n server listning";

}

tcpserverobject::~tcpserverobject()
{

   // to do
    while (!TcpSocketThreadWrapperObjectList.isEmpty())
        delete TcpSocketThreadWrapperObjectList.takeFirst();
}

void tcpserverobject::on_newConnection()
{
    QByteArray block;

    block.append(" \n Hello from server .. !!!") ;

    QTcpSocket *clientConnection = tcpServer->nextPendingConnection();
    connect(clientConnection, SIGNAL(disconnected()),
                clientConnection, SLOT(deleteLater()));

    // Create new thread for this .. client request ..!!
    qDebug() << "\n New connection request ..!!!";
    qDebug() << "\n New client from:" << clientConnection->peerAddress().toString();

    clientConnection->write(block);
    clientConnection->flush();

    // create new tcp object
    TcpSocketThreadWrapperObject* TcpSocketThreadWrapperObjectPtr = new TcpSocketThreadWrapperObject(clientConnection);

    // Append object to the list
    TcpSocketThreadWrapperObjectList.append(TcpSocketThreadWrapperObjectPtr);

}

============ TcpSocketThreadWrapperObject ==============

// Main device thread object
class TcpSocketThreadWrapperObject : public QObject
{
    Q_OBJECT
public:
    explicit TcpSocketThreadWrapperObject(QTcpSocket *m_pTcpSocket , QObject *parent = 0);
    ~TcpSocketThreadWrapperObject();

    /*!
        pointer for write thread
    */
    QThread m_TcpSocketRWThread;

    /// pointer to the socketthread  object
    class TcpSocketThreadObject *m_pTcpSocketThreadObject;


signals:

public slots:

};


// constructor for the deviceThreadObject
TcpSocketThreadWrapperObject::TcpSocketThreadWrapperObject(QTcpSocket *m_pTcpSocket , QObject *parent) :
    QObject(parent)
{
    m_pTcpSocketThreadObject = new TcpSocketThreadObject(m_pTcpSocket);

    //set flag for event loop -- make while(1)
    m_pTcpSocketThreadObject->m_bQuit = false;
    // connect the signal & slot
    connect(&m_TcpSocketRWThread,SIGNAL(started()),m_pTcpSocketThreadObject,SLOT(dowork_socket()));
    // Move thread to object
    m_pTcpSocketThreadObject->moveToThread(&m_TcpSocketRWThread);

    //Start the thread
    m_TcpSocketRWThread.start();

}

TcpSocketThreadWrapperObject::~TcpSocketThreadWrapperObject()
{

    //set flag for event loop -- make while(0)
    m_pTcpSocketThreadObject->m_bQuit = false;

    // Wait for the thread to terminate
    m_TcpSocketRWThread.quit();
    m_TcpSocketRWThread.wait();

    // Delete the object
    m_pTcpSocketThreadObject->deleteLater();

    qDebug() << "\n deleted - TcpSocketThreadWrapperObject";

}

======== TcpSocketThreadObject 对象 ========

class TcpSocketThreadObject : public QObject
{
    Q_OBJECT
public:
    explicit TcpSocketThreadObject(QTcpSocket *m_pTcpSocketTemp , QObject *parent = 0);
    ~TcpSocketThreadObject();

    /*!
        Pointer to TCP socket -- created by the server
    */
    QTcpSocket *m_pclientConnectionSocket;


    /*!
      Termination control main thread
    */
    volatile  bool m_bQuit;

signals:

public slots:
    void dowork_socket();

};


// constructor for the deviceThreadObject
TcpSocketThreadObject::TcpSocketThreadObject(QTcpSocket *m_pTcpSocketTemp , QObject *parent) :
    QObject(parent)
{
    m_pclientConnectionSocket = m_pTcpSocketTemp;

    // todo
}

TcpSocketThreadObject::~TcpSocketThreadObject()
{
    // todo

}

void TcpSocketThreadObject::dowork_socket()
{
    QByteArray block;

    block.append(" \n hi again .. !!!") ;

    // Write to socket
    m_pclientConnectionSocket->write(block);
    m_pclientConnectionSocket->flush();

    // Close socket
    m_pclientConnectionSocket->disconnectFromHost();
    qDebug() << "\n entring loop of socket thread ..!!!";

    while(!m_bQuit)
    {
        // while loop --> send/rx command from client
    }

}

======= 一个连接到服务器的客户端的输出 =====

 New connection request ..!!! 

 New client from: "127.0.0.1" 
QSocketNotifier: socket notifiers cannot be enabled from another thread
QSocketNotifier: socket notifiers cannot be disabled from another thread

 entring loop of socket thread ..!!!
4

1 回答 1

0

我认为最简单的解决方案是停止使用 QThread。

QTcpSocket 和 QTcpServer 都是异步的，所以当你接收到一个连接时，你只需要创建一个类来包装 QTcpSocket 并且这个类处理数据的读取，将 QTcpSocket 信号连接到类的插槽。

如果您获得大量连接，那么您将创建大量线程。多于处理器内核的线程只是浪费时间。

如果每个连接都请求服务器完成大量工作，那么您可以创建单独的工作对象并将它们移动到不同的线程，但总的来说，我建议您不要为 QTcpServer 和 QTcpSockets 使用单独的线程。

于 2013-11-21T16:00:31.217 回答