Как сделать блокировку tcp-сокета с Qt?

Question

Я работаю с QTcpSocket. Мне нужно, чтобы любые вызовы записи/чтения в сокет были синхронными (блокирование).

Я знаю, что есть waitForReadyRead() и waitForBytesWritten(), но эти два метода отмечены в документации Qt, так как они могут случайно произойти под Windows. Я этого не могу.

Чтение блокировки является самым важным (так как чтение всегда начинается после подачи команды другому партнеру, поэтому я знаю, что если данные достигнут другого партнера, он ответит).

Я пробовал 2 подхода.

Первое:

QByteArray readBytes(qint64 count) 
{ 
    int sleepIterations = 0; 
    QByteArray resultBytes; 
    while (resultBytes.size() < count && sleepIterations < 100) 
    { 
     if (socket->bytesAvailable() == 0) 
     { 
      sleepIterations++; 
      QThread::msleep(100); 
      QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents); 
      continue; 
     } 

     resultBytes += socket->read(qMin(count, socket->bytesAvailable())); 
    } 
    return resultBytes; 
} 

Это должно ждать байтов, будут доступны для чтения на сокете, обрабатывая цикл событий в то же время, так что гнездо делает это необходимым внутреннее вещество.

К сожалению - по неизвестной мне причине - bytesAvailable() иногда возвращает правильное число байтов, но иногда это не что-либо большее, чем 0.

Я знаю, что на самом деле, что там были данные не возвращается для чтения, так как он используется для работы со вторым подходом (но у него есть свои проблемы).

Второе:

У меня есть вид сигнала «блокаторов», который блокирует текущий контекст и обрабатывает цикл событий, пока определенный сигнал не излучается. Это "блокиратор":

SignalWait.h:

class SignalWait : public QObject 
{ 
     Q_OBJECT 

    public: 
     SignalWait(QObject *object, const char *signal); 

     bool wait(int msTimeout); 

    private: 
     bool called = false; 

    private slots: 
     void handleSignal(); 
}; 

SignalWait.cpp:

SignalWait::SignalWait(QObject* object, const char* signal) : 
    QObject() 
{ 
    connect(object, signal, this, SLOT(handleSignal())); 
} 

bool SignalWait::wait(int msTimeout) 
{ 
    QTime timer(0, 0, 0, msTimeout); 
    timer.start(); 
    while (!called && timer.elapsed() < msTimeout) 
     QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents); 

    return called; 
} 

void SignalWait::handleSignal() 
{ 
    called = true; 
} 

, а затем я использовал это так:

SignalWait signalWait(socket, SIGNAL(readyRead())); 
// ... 
// socket->write(...); 
// ... 
if (!signalWait.wait(30000)) 
{ 
    // error 
    return; 
} 
bytes = socket->read(size); 

Этот подход кажется, работает лучше, но время от времени он также терпит неудачу. Я не знаю почему. Это как сигнал readyRead() никогда не излучался, и SignalWait продолжает ждать, пока он не истечет.

У меня нет идей. Каков правильный способ справиться с этим?

Answer 1

Я хотел бы предложить использовать асинхронный подход, но если вы действительно хотите идти с синхронным способом, то лучшим способом будет использовать локальный цикл обработки событий:

QTimer timer; 
timer.setSingleShot(true); 
QEventLoop loop; 
loop.connect(socket, SIGNAL(readyRead()), SLOT(quit())); 
connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); 

while (resultBytes.size() < count) 
{ 
    timer.start(msTimeout); 
    loop.exec(); 

    if(timer.isActive()) 
     resultBytes += socket->read(qMin(count, socket->bytesAvailable())); 
    else 
     break; 
} 

Здесь он ждет, пока count байт не чтения или таймаута.