CODEWITHSUNDEEP
c++boostasiostreambuf
junya
junya

Reputation: 21

Boost Asio: Strange when use streambuf and async_write in mutl-thread

My program has a buffer when sending data. Instead of directly calling async_write every time for send small packets, try to make the send method return quickly, use streambuf as the sending buffer, and try to send large packets.

The problem encountered now is that when multiple threads call send at the same time, there is a small probability that the opposite end may receive duplicate data packets or messy data. Here is my code:

void ClientConnection::send(const string* buffer, function<void (bool status)> callback) {
    {
        unique_lock<mutex> lck(*_ioLockPtr);
        ostream os(_sendBufferPtr.get());
        os << *buffer;
    }
    delete buffer;
    callback(true);
    _sendBuffer();
}

void ClientConnection::_sendBuffer() {
    unique_lock<mutex> lck(*_ioLockPtr);

    size_t bufferSize = _sendBufferPtr->size();
    if (!bufferSize || _sendingBufferCount > 0) {
        return;
    }

    ++_sendingBufferCount;
    async_write(*_socketPtr, _sendBufferPtr->data(), boost::asio::transfer_exactly(bufferSize), boost::bind(&ClientConnection::_handleWrite, 
        shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));

    _sendBufferPtr->consume(bufferSize);
}

void ClientConnection::_handleWrite(const boost::system::error_code& error, size_t bytes_transferred) {
    if (!error) {
        unique_lock<mutex> lck(*_ioLockPtr);

        size_t bufferSize = _sendBufferPtr->size();

        if (bufferSize) {
            async_write(*_socketPtr, _sendBufferPtr->data(), boost::asio::transfer_exactly(bufferSize), boost::bind(&ClientConnection::_handleWrite, 
                shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));

            _sendBufferPtr->consume(bufferSize);

        } else {
            --_sendingBufferCount;
        }
    } else {
        {
            unique_lock<mutex> lck(*_ioLockPtr);
            --_sendingBufferCount;
        }
        _close();
    }
}

The relevant variables are defined as follows：

shared_ptr<boost::asio::streambuf> _sendBufferPtr;
uint8_t _sendingBufferCount;

Please help me to understand how to solve this problem, thanks!

Upvotes: 2

Views: 291

Answers (1)

sehe
sehe

Reputation: 392893

The problem encountered now is that when multiple threads call send at the same time

This is strictly prohibited as per the documentation:

This operation is implemented in terms of zero or more calls to the stream's async_write_some function, and is known as a composed operation. The program must ensure that the stream performs no other write operations (such as async_write, the stream's async_write_some function, or any other composed operations that perform writes) until this operation completes.

To serialize the async operations, you may want to use a strand.

Upvotes: 2

Related Questions