如何有效地使用 boost::process::async_pipe 进行读写？

Question

我已经看到了boost::process tutorial... 但是这里的例子是一次写入然后从子进程读取一次。我想知道在子进程生命周期内是否有可能让两个 async_pipes 都处于活动状态（读取和写入）。

我在从 child->parent 管道（read_pipe，在我的代码中）读取时遇到问题。我只能在关闭父->子管道 (write_pipe) 后读取它，但这意味着我不会再在这个子进程上写任何东西，对吧？这是有道理的，但是有一些解决方法可以保持双向通道吗？我的最终目标是在读取和写入块之间不断交替。

#include <boost/asio.hpp>
#include <boost/process.hpp>
#include <iostream>
#include <string>
#include <vector>

typedef std::function<void(const boost::system::error_code & ec, std::size_t n)> Handler;

int main(){
    
    std::vector<char> vread_buffer(4096);
    boost::asio::io_service ios;
    boost::process::async_pipe read_pipe{ios};
    boost::process::async_pipe write_pipe{ios};
    auto child_process = boost::process::child(  "stockfish_12_win_x64/stockfish_20090216_x64.exe" , 
                                                boost::process::std_in  <  write_pipe ,
                                                boost::process::std_out >  read_pipe  );
    

    Handler on_stdout,on_stdin;
    std::string read_string;

    on_stdout = [&](const boost::system::error_code & ec, size_t n){
        std::cout << "I'm reading " << n << " characters from the child process. Can't wait for more!" << std::endl;
        read_string.reserve( read_string.size() + n );
        read_string.insert( read_string.end() , vread_buffer.begin() , vread_buffer.begin() + n );
        if(!ec) boost::asio::async_read( read_pipe , boost::asio::buffer(vread_buffer) , on_stdout );
    };
    on_stdin = [&]( const boost::system::error_code & ec, std::size_t n ){
        std::cout << "I know that " << n << " characters were sent to the process. Yay! " << std::endl;
    };

    // {...} Suppose an undefined amount of time has passed 

    // Expected: To see the initial print from the program calling the on_stdout
    // ... but it doesn't call anything.
    boost::asio::async_read( read_pipe , boost::asio::buffer(vread_buffer) ,  on_stdout );
    ios.poll();
    ios.restart();


    // Expected: To see the "on_stdin" handler being called... and it was!
    std::string write_string = "uci\n";
    boost::asio::async_write( write_pipe , boost::asio::buffer(write_string) ,  on_stdin );
    ios.poll();
    ios.restart();
    
    // Sending a async_read will never do anything unless I close the write_pipe.
    // How can I tell the io_service that last write was done so I can read again?
    boost::asio::async_read( read_pipe , boost::asio::buffer(vread_buffer) ,  on_stdout );
    ios.poll();
    ios.restart();

    
}

Answer 1

我想我明白了。我应该使用boost::asio::async_read_until 传递分隔符（字符/正则表达式/字符串）而不是boost::asio::async_read

这样，boost::process::buffer应该改成boost::asio::dynamic_buffer

std::string read_string;
auto d_buffer = boost::asio::dynamic_buffer(read_string);

// First read
boost::asio::async_read_until( read_pipe , d_buffer  , '\n' , on_stdout );
ios.poll();
ios.restart();

// Any amount of writes can be done here with async_write

// Second read
d_buffer.consume(d_buffer.size(); // Will append new content into read_string anyway, this is just to read_string doesn't grow indefinitely. Also, I noted unexpected behavior if not consume all content (new content appended at random middle points)
boost::asio::async_read_until( read_pipe , d_buffer  , '\n' , on_stdout );
ios.poll();
ios.restart();