我的问题

Question

我的问题

当使用两个线程通过asio::ip::tcp::iostream发送和接收时，如何避免数据竞争？

设计

我正在编写一个使用asio::ip::tcp::iostream输入和输出的程序。程序通过端口5555接受来自（远程）用户的命令，并通过相同的TCP连接将消息发送给用户。因为这些事件（从用户接收的命令或发送给用户的消息）是异步发生的，所以我有单独的发送和接收线程。

在这个玩具版本中，命令是＆＃34;一个＆＃34;，＆＃34;两个＆＃34;和＆＃34;退出＆＃34;。当然＆＃34;退出＆＃34;退出程序。其他命令不执行任何操作，任何无法识别的命令都会导致服务器关闭TCP连接。

传输的消息是简单的序列编号消息，每秒发送一次。

在这个玩具版本和我尝试编写的真实代码中，发送和接收进程都使用了阻塞IO，所以似乎不是一个使用{{{}的好方法。 1}}或其他同步机制。（在我的尝试中，一个进程会获取互斥锁然后阻塞，这对此无效。）

构建和测试

为了构建和测试它，我在64位Linux机器上使用gcc版本7.2.1和valgrind 3.13。建立：

std::mutex

要测试，我使用以下命令运行服务器：

g++ -DASIO_STANDALONE -Wall -Wextra -pedantic -std=c++14 concurrent.cpp -o concurrent -lpthread

然后我在另一个窗口中使用valgrind --tool=helgrind --log-file=helgrind.txt ./concurrent来创建与服务器的连接。 telnet 127.0.0.1 5555正确指出的是数据竞争，因为helgrind和runTx都试图异步访问同一个数据流：

== 16188 ==线程＃1在0x1FFEFFF1CC读取大小1时可能发生数据竞争

== 16188 ==持有的锁：无

......更多的线路被淘汰

concurrent.cpp

runRx

Answer 1

是的，你正在共享流的基础套接字，没有同步

Sidenote，与布尔标志相同，可以通过更改：
轻松“修复”
std::atomic_bool want_quit;
std::atomic_bool want_reset;

如何解决

说实话，我认为没有一个好的解决方案。你自己说过：操作是异步的，所以如果你试图同步它们就会遇到麻烦。

你可以试着想一下黑客。如果我们基于相同的底层套接字（filedescriptor）创建了一个单独的流对象，该怎么办？它不会非常容易，因为这样的流不是Asio的一部分。

但我们可以使用Boost Iostreams攻击一个：

#define BOOST_IOSTREAMS_USE_DEPRECATED
#include <boost/iostreams/device/file_descriptor.hpp>
#include <boost/iostreams/stream.hpp>

// .... later:

    // HACK: procure a _separate `ostream` to prevent the race, using the same fd
    namespace bio = boost::iostreams;
    bio::file_descriptor_sink fds(stream.rdbuf()->native_handle(), false); // close_on_exit flag is deprecated
    bio::stream<bio::file_descriptor_sink> hack_ostream(fds);

    con.run(stream, hack_ostream);

实际上，这种情况在没有竞争的情况下运行（在同一个套接字are fine上同时读取和写入，只要您不共享包装它们的非线程安全的Asio对象）。

我推荐的内容：

不要那样做。这是一个kludge。你使事情变得复杂，显然是为了避免使用异步代码。我咬紧牙关。

将IO机制从服务逻辑中分解出来并不算太多。您将最终摆脱随机限制（您可以考虑处理多个客户端，您可以在没有任何线程的情况下完成等。）

如果您想了解一些中间立场，请查看堆叠协程（http://www.boost.org/doc/libs/1_66_0/doc/html/boost_asio/reference/spawn.html）

清单

仅供参考

注意我重构了删除指针的需要。您没有转让所有权，因此可以参考。如果您不知道如何将引用传递给bind / std::thread构造函数，那么诀窍就在您将看到的std::ref中。

[对于压力测试，我已经大大减少了延误。]

<强> Live On Coliru

#include <boost/asio.hpp>
#include <iostream>
#include <fstream>
#include <thread>
#include <array>
#include <chrono>

class Console {
public:
    Console() :
        want_quit{false},
        want_reset{false}
    {}
    bool getQuitValue() const { return want_quit; }
    int run(std::istream &in, std::ostream &out);
    bool wantReset() const { return want_reset; }
private:
    int runTx(std::istream &in);
    int runRx(std::ostream &out);
    std::atomic_bool want_quit;
    std::atomic_bool want_reset;
};

int Console::runTx(std::istream &in) {
    static const std::array<std::string, 3> cmds{
        {"quit", "one", "two"}, 
    };
    std::string command;
    while (!want_quit && !want_reset && in >> command) {
        if (command == cmds.front()) {
            want_quit = true;
        }
        if (std::find(cmds.cbegin(), cmds.cend(), command) == cmds.cend()) {
            want_reset = true;
            std::cout << "unknown command [" << command << "]\n";
        } else {
            std::cout << command << '\n';
        }
    }
    return 0;
}

int Console::runRx(std::ostream &out) {
    for (int i=0; !(want_reset || want_quit); ++i) {
        out << "This is message number " << i << '\n';
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        out.flush();
    }
    return 0;
}

int Console::run(std::istream &in, std::ostream &out) {
    want_reset = false;
    std::thread t1{&Console::runRx, this, std::ref(out)};
    int status = runTx(in);
    t1.join();
    return status;
}

#define BOOST_IOSTREAMS_USE_DEPRECATED
#include <boost/iostreams/device/file_descriptor.hpp>
#include <boost/iostreams/stream.hpp>

int main()
{
    Console con;
    boost::asio::io_service ios;

    // IPv4 address, port 5555
    boost::asio::ip::tcp::acceptor acceptor(ios, boost::asio::ip::tcp::endpoint{boost::asio::ip::tcp::v4(), 5555});

    while (!con.getQuitValue()) {
        boost::asio::ip::tcp::iostream stream;
        acceptor.accept(*stream.rdbuf());

        {
            // HACK: procure a _separate `ostream` to prevent the race, using the same fd
            namespace bio = boost::iostreams;
            bio::file_descriptor_sink fds(stream.rdbuf()->native_handle(), false); // close_on_exit flag is deprecated
            bio::stream<bio::file_descriptor_sink> hack_ostream(fds);

            con.run(stream, hack_ostream);
        }

        if (con.wantReset()) {
            std::cout << "resetting\n";
        }
    }
}

测试：

netcat localhost 5555 <<<quit
This is message number 0
This is message number 1
This is message number 2

和

commands=( one two one two one two one two one two one two one two three )
while sleep 0.1; do echo ${commands[$(($RANDOM%${#commands}))]}; done | (while netcat localhost 5555; do sleep 1; done)

无限期运行，偶尔重置连接（当命令“3”已发送时）。

如何避免使用`asio :: ip :: tcp :: iostream`进行数据竞争？

我的问题

设计

构建和测试

concurrent.cpp

1 个答案:

如何解决

我推荐的内容：

清单