Estou tentando simularboost::asio::write com tempo limite. Ou você pode dizer, estou tentando usarboost::asio::async_write com um tempo limite.

Como eu vejo,boost::asio::write bloqueia até que todos os dados tenham sidoescrito e lido por outro lado. Esse tipo de funcionalidade certamente requer um tempo limite.

Assim, Lendo atravésesta resposta simples aqui porRobert Hegner que demonstra como fazer umboost::asio::async_read comtempo esgotado, Eu soutentando adaptar a mesma lógica para escrever ao fazê-lo:

size_t write_data_with_time_out() {

    long time_out_secs = 2;

    boost::optional<boost::system::error_code> timer_result;
    boost::asio::deadline_timer timer(the_socket->get_io_service(), boost::posix_time::seconds(time_out_secs));

    timer.expires_from_now();
    timer.async_wait([&timer_result] (const boost::system::error_code& error) {
        timer_result.reset(error);
    });

    boost::optional<boost::system::error_code> write_result;
    size_t bytes_sent = 0;
    boost::asio::async_write(*the_socket, boost::asio::buffer(the_buffer_to_write, the_buffer_to_write.size()), [&write_result, &bytes_sent] (const boost::system::error_code& error, auto size_received) {

        write_result.reset(error);
        bytes_sent = size_received;
    });

    the_socket->get_io_service().reset();
    while (the_socket->get_io_service().run_one()) {

        if (write_result) {
            timer.cancel();
        }
        else if (timer_result) {
            the_socket->cancel();
        }
    }

    if (*write_result) {
        return 0;
    }

    return bytes_sent;
}

Problema:
A lógica funciona muito bem para leituramas parece não funcionar para caso de gravação.Razão, motivo é aquelewhile (the_socket->get_io_service().run_one()) fica pendurado depois de ligarthe_socket->cancel() duas vezes.

Contudo, no caso de leitura tambémthe_socket->cancel() é chamado duas vezes e não fica suspenso no terceiro loop ao longo do tempo e retorna. Portanto, não há problemas com a leitura.

Pergunta, questão:
O meu entendimento está errado da mesma maneiralógica de tempo limite trabalharia paraboost::asio::async_write caso? Eu acho que essa mesma lógica deve funcionar. Estou fazendo algo errado, e é nisso que preciso sugerir.

Informações adicionais necessárias, se possível:
E seboost::asio::read & boost::asio::write tinha um parâmetro de tempo limite. Eu não teria escrito esse extra. Parece que houve muitas solicitações para que asio pessoal introduzisse um tempo limite em suas funções de leitura e gravação de sincronização. Gostareste aqui.É Existe algum escopo para asio pessoal atender a essa solicitação em um futuro próximo?

Estou fazendo uma sincronizaçãoboost::asio::read & boost::asio::write no mesmo soquete usando um thread de trabalho para o qual isso funciona de maneira excelente. Tudo o que falta é essa funcionalidade de tempo limite.

Meio Ambiente:
Meu código é executado emLinux & MacOSX com o compilador C ++ 14. Esta questão diz respeito apenasSoquetes TCP.