c++ - 在调用 std::bind 的乘积后意外调用析构函数-6ren

c++ - 在调用 std::bind 的乘积后意外调用析构函数

转载作者：行者123 更新时间：2023-12-01 15:08:19

有一个使用 boost::asio::io_context 的简单示例

https://github.com/unegare/boost-ex/blob/500e46f4d3b41e2abe48e2deccfab39d44ae94e0/main.cpp


    #include <boost/asio.hpp>
    #include <boost/beast/core.hpp>
    #include <boost/beast/http.hpp>
    #include <boost/beast/version.hpp>
    #include <thread>
    #include <vector>
    #include <memory>
    #include <mutex>
    #include <chrono>
    #include <iostream>
    #include <exception>

    std::mutex m_stdout;

    class MyWorker {
      std::shared_ptr<boost::asio::io_context> io_context;
      std::shared_ptr<boost::asio::executor_work_guard<boost::asio::io_context::executor_type>> work_guard;
    public:
      MyWorker(std::shared_ptr<boost::asio::io_context> &_io_context, std::shared_ptr<boost::asio::executor_work_guard<boost::asio::io_context::executor_type>> &_work_guard):
        io_context(_io_context), work_guard(_work_guard) {}
      MyWorker(const MyWorker &mw): io_context(mw.io_context), work_guard(mw.work_guard) {
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] MyWorker copy constructor" << std::endl;
        m_stdout.unlock();
      }
      MyWorker(MyWorker &&mw): io_context(std::move(mw.io_context)), work_guard(std::move(mw.work_guard)) {
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] MyWorker move constructor" << std::endl;
        m_stdout.unlock();
      }
      ~MyWorker() {}

      void operator() () {
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] Thread Start" << std::endl;
        m_stdout.unlock();

        while(true) {
          try {
            boost::system::error_code ec;
            io_context->run(ec);
            if (ec) {
              m_stdout.lock();
              std::cout << "[" << std::this_thread::get_id() << "] MyWorker: received an error: " << ec << std::endl;
              m_stdout.unlock();
              continue;
            }
            break;
          } catch (std::exception &ex) {
            m_stdout.lock();
            std::cout << "[" << std::this_thread::get_id() << "] MyWorker: caught an exception: " << ex.what() << std::endl;
            m_stdout.unlock();
          }
        }

        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] Thread Finish" << std::endl;
        m_stdout.unlock();
      }
    };

    class Client: public std::enable_shared_from_this<Client> {
      std::shared_ptr<boost::asio::io_context> io_context;
      std::shared_ptr<boost::asio::executor_work_guard<boost::asio::io_context::executor_type>> work_guard;
      std::shared_ptr<boost::asio::ip::tcp::socket> sock;
      std::shared_ptr<std::array<char, 512>> buff;
    public:
      Client(std::shared_ptr<boost::asio::io_context> &_io_context, std::shared_ptr<boost::asio::executor_work_guard<boost::asio::io_context::executor_type>> &_work_guard, std::shared_ptr<boost::asio::ip::tcp::socket> &_sock):
        io_context(_io_context), work_guard(_work_guard), sock(_sock) {
        buff = std::make_shared<std::array<char,512>>();
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] " << __FUNCTION__ << " with args" << std::endl;
        m_stdout.unlock();
      }
      Client(const Client &cl): io_context(cl.io_context), work_guard(cl.work_guard), sock(cl.sock), buff(cl.buff) {
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] " << __FUNCTION__ << " copy" << std::endl;
        m_stdout.unlock();
      }
      Client(Client &&cl): io_context(std::move(cl.io_context)), work_guard(std::move(cl.work_guard)), sock(std::move(cl.sock)), buff(std::move(cl.buff)) {
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] " << __FUNCTION__ << " move" << std::endl;
        m_stdout.unlock();
      }
      ~Client() {
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] " << __FUNCTION__ << " buff.use_count: " << buff.use_count() << " | sock.use_count: " << sock.use_count() << " | io_context.use_count: " << io_context.use_count() << std::endl;
        m_stdout.unlock();
      }

      void OnConnect(const boost::system::error_code &ec) {
        std::cout << __FUNCTION__ << std::endl;
        if (ec) {
          m_stdout.lock();
          std::cout << "[" << std::this_thread::get_id() << "] " << __FUNCTION__ << ": " << ec << std::endl;
          m_stdout.unlock();
        } else {
    //      buff = std::make_shared<std::array<char, 512>>();
          char req[] = "GET / HTTP/1.1\r\nHost: unegare.info\r\n\r\n";
          memcpy(buff->data(), req, strlen(req));
          m_stdout.lock();
          std::cout << req << std::endl;
          m_stdout.unlock();
          sock->async_write_some(boost::asio::buffer(buff->data(), strlen(buff->data())), std::bind(std::mem_fn(&Client::OnSend), this, std::placeholders::_1, std::placeholders::_2));
        }
        std::cout << __FUNCTION__ << " use_count: " << buff.use_count() << std::endl;
      }

      void OnSend(const boost::system::error_code &ec, std::size_t bytes_transferred) {
        std::cout << __FUNCTION__ << " use_count: " << io_context.use_count() << std::endl;
        if (ec) {
          m_stdout.lock();
          std::cout << "[" << std::this_thread::get_id() << "] " << __FUNCTION__ << ": " << ec << std::endl;
          m_stdout.unlock();
        } else {
        std::cout << __FUNCTION__ << " use_count: " << buff.use_count() << std::endl;
          buff->fill(0);
        std::cout << __FUNCTION__ << std::endl;
          sock->async_read_some(boost::asio::buffer(buff->data(), buff->size()), std::bind(std::mem_fn(&Client::OnRecv), this, std::placeholders::_1, std::placeholders::_2));
        }
      }

      void OnRecv(const boost::system::error_code &ec, std::size_t bytes_transferred) {
        std::cout << __FUNCTION__ << std::endl;
        if (ec) {
          m_stdout.lock();
          std::cout << "[" << std::this_thread::get_id() << "] " << __FUNCTION__ << ": " << ec << std::endl;
          m_stdout.unlock();
        } else {
          m_stdout.lock();
          std::cout << buff->data() << std::endl;
          m_stdout.unlock();
        }
      }
    };

    int main () {
      std::shared_ptr<boost::asio::io_context> io_context(std::make_shared<boost::asio::io_context>());
      std::shared_ptr<boost::asio::executor_work_guard<boost::asio::io_context::executor_type>> work_guard(
        std::make_shared<boost::asio::executor_work_guard<boost::asio::io_context::executor_type>> (boost::asio::make_work_guard(*io_context))
      );
      MyWorker mw(io_context, work_guard);
      std::vector<std::thread> vth;
      vth.reserve(1);
      for (int i = 1; i > 0; --i) {
        vth.emplace_back(mw);
      }
      std::shared_ptr<Client> cl = 0;
      try {
        boost::asio::ip::tcp::resolver resolver(*io_context);
        boost::asio::ip::tcp::resolver::query query("unegare.info", "80");
        boost::asio::ip::tcp::endpoint ep = *resolver.resolve(query);
        m_stdout.lock();
        std::cout << "ep: " << ep << std::endl;
        m_stdout.unlock();

        std::shared_ptr<boost::asio::ip::tcp::socket> sock(std::make_shared<boost::asio::ip::tcp::socket>(*io_context));
        std::shared_ptr<Client> cl2(std::make_shared<Client>(io_context, work_guard, sock));
        cl = cl2->shared_from_this();
        m_stdout.lock();
        std::cout << "HERE: use_count = " << cl.use_count() << std::endl;
        m_stdout.unlock();
        sock->async_connect(ep, std::bind(std::mem_fn(&Client::OnConnect), *cl2->shared_from_this(), std::placeholders::_1));
        std::this_thread::sleep_for(std::chrono::duration<double>(1));
        m_stdout.lock();
        std::cout << "AFTER CALL" << std::endl;
        m_stdout.unlock();
    //    asm volatile ("");
      } catch (std::exception &ex) {
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] Main Thread: caught an exception: " << ex.what() << std::endl;
        m_stdout.unlock();
      }
      try {
        char t;
        std::cin >> t;
        work_guard->reset();
    //    std::this_thread::sleep_for(std::chrono::duration<double>(1));
    //    std::cout << "Running" << std::endl;
    //    io_context->run();
      } catch (std::exception &ex) {
        m_stdout.lock();
        std::cout << "[" << std::this_thread::get_id() << "] Main Thread: caught an exception: " << ex.what() << std::endl;
        m_stdout.unlock();
      }
      std::for_each(vth.begin(), vth.end(), std::mem_fn(&std::thread::join));
      return 0;
    }

标准输出:

[140487203505984] MyWorker copy constructor
[140487203505984] MyWorker move constructor
[140487185372928] Thread Start
ep: 95.165.130.37:80
[140487203505984] Client with args
HERE: use_count = 2
[140487203505984] Client copy
[140487203505984] Client move
[140487203505984] ~Client buff.use_count: 0 | sock.use_count: 0 | io_context.use_count: 0
[140487185372928] Client move
[140487185372928] ~Client buff.use_count: 0 | sock.use_count: 0 | io_context.use_count: 0
OnConnect
GET / HTTP/1.1
Host: unegare.info


OnConnect use_count: 2
[140487185372928] ~Client buff.use_count: 2 | sock.use_count: 3 | io_context.use_count: 5
Segmentation Fault (core dumped)

但是对 Client的引用不好导致的segfault理解有点问题目的。

但是我不明白为什么 cl2调用后被破坏

sock->async_connect(ep, std::bind(std::mem_fn(&Client::OnConnect), *cl2->shared_from_this(), std::placeholders::_1));

在 162 线。

还有……为什么要调用复制构造函数？
从 stdout 中可能会注意到多于。

最佳答案

你试着去理解很好。但是，从简单开始!

您的复制构造函数未能调用基类复制构造函数 (!!) 哎呀

你的绑定(bind)绑定(bind)到

this (不会使共享指针保持事件状态)

*cl2->shared_from_this() - 哎呀，这绑定(bind)到 *cl2 的拷贝按值(value)¹。这显然是当你完成

时 COPY 被破坏的原因。

无效引用来自 1. 和 2.b 的组合。

我建议简化。很多!

使用零规则(仅在需要时声明特殊成员。在此，您引入了一个错误，因为您手动编写了一个不需要的复制构造函数)

在适当的情况下使用非拥有引用(并非所有内容都需要是智能指针)

首选 std::unique_ptr对于不需要共享所有权的东西(共享所有权应该很少见)

首选 std::lock_guard而不是手动锁定和解锁(这不是异常安全的)

许多其他人:work_guard不需要复制，有reset()成员已经，通过 const-reference 捕获，如果你要捕获，不需要使用 error_code在 io_context::run ，检查resolve的端点迭代器在取消引用之前，使用 boost::asio::connect相反，您不必检查和迭代不同的端点等。

更喜欢 std::string如果您无论如何要进行动态分配，则在固定大小的缓冲区上，使用非实现定义的计时持续时间(例如 1.0s ，而不是 duration<double>(1) )，考虑使用 boost::thread_group而不是 vector<std::thread>或至少只加入 joinable() 的线程等

建议做 async_connect Client 的一部分，从那时起，您可以像所有其他绑定(bind)一样简单地绑定(bind)成员(使用 shared_from_this() ，而不是编写您遇到的错误)

如果您还有时间，请考虑使用 Beast 来创建/解析 Http 请求和响应

作为引用，这是 MyWorker可能:

class MyWorker {
    ba::io_context& io_context;

  public:
    MyWorker(ba::io_context& _io_context) : io_context(_io_context) {}

    //// best is to not mention these at all, because even `default`ing can change what compiler generates
    //MyWorker(const MyWorker& mw) = default;
    //MyWorker(MyWorker&& mw) = default;
    //~MyWorker() = default;

    void operator()() {
        TRACE("Thread Start");

        while (true) {
            try {
                io_context.run();
                break; // normal end
            } catch (boost::system::system_error const& se) {
                TRACE("MyWorker: received an error: " << se.code().message());
            } catch (std::exception const& ex) {
                TRACE("MyWorker: caught an exception: " << ex.what());
            }
        }

        TRACE("Thread Finish");
    }
};

此时，您可以很好地将其设为 lambda:

auto mw = [&io_context] {
        TRACE("Thread Start");

        while (true) {
            try {
                io_context.run();
                break; // normal end
            } catch (boost::system::system_error const& se) {
                TRACE("MyWorker: received an error: " << se.code().message());
            } catch (std::exception const& ex) {
                TRACE("MyWorker: caught an exception: " << ex.what());
            }
        }

        TRACE("Thread Finish");
    };

简单得多。

完整的代码简化

看看例如新连接代码的简单性:

void Start() {
    tcp::resolver resolver(io_context);
    ba::async_connect(sock,
        resolver.resolve({"unegare.info", "80"}),
        [self=shared_from_this()](error_code ec, tcp::endpoint) { self->OnConnect(ec); });
}

端点在 OnConnect 时打印。叫做。

Live On Coliru²

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <iomanip>
#include <iostream>
#include <memory>
#include <mutex>

namespace ba = boost::asio;
using ba::ip::tcp;
using namespace std::literals;

static std::mutex s_stdout;
#define TRACE(expr) { \
    std::lock_guard<std::mutex> lk(s_stdout); \
    std::cout << "[" << std::this_thread::get_id() << "] " << expr << std::endl; \
}

class Client : public std::enable_shared_from_this<Client> {
    ba::io_context& io_context;
    tcp::socket sock;
    std::string buf;

  public:
    Client(ba::io_context& _io_context) : io_context(_io_context), sock{io_context}
    { }

    void Start() {
        tcp::resolver resolver(io_context);
        ba::async_connect(sock,
                resolver.resolve({"unegare.info", "80"}),
                std::bind(std::mem_fn(&Client::OnConnect), shared_from_this(), std::placeholders::_1));
    }

    void OnConnect(const boost::system::error_code& ec) {
        TRACE(__FUNCTION__ << " ep:" << sock.remote_endpoint());
        if (ec) {
            TRACE(__FUNCTION__ << ": " << ec.message());
        } else {
            buf = "GET / HTTP/1.1\r\nHost: unegare.info\r\n\r\n";
            TRACE(std::quoted(buf));
            sock.async_write_some(ba::buffer(buf),
               std::bind(std::mem_fn(&Client::OnSend), shared_from_this(), std::placeholders::_1, std::placeholders::_2));
        }
    }

    void OnSend(const boost::system::error_code& ec, std::size_t bytes_transferred) {
        if (ec) {
            TRACE(__FUNCTION__ << ": " << ec.message() << " and bytes_transferred: " << bytes_transferred);
        } else {
            TRACE(__FUNCTION__);
            buf.assign(512, '\0');
            sock.async_read_some(ba::buffer(buf), std::bind(std::mem_fn(&Client::OnRecv), shared_from_this(), std::placeholders::_1, std::placeholders::_2));
        }
    }

    void OnRecv(const boost::system::error_code& ec, std::size_t bytes_transferred) {
        TRACE(__FUNCTION__);
        if (ec) {
            TRACE(__FUNCTION__ << ": " << ec.message() << " and bytes_transferred: " << bytes_transferred);
        } else {
            buf.resize(bytes_transferred);
            TRACE(std::quoted(buf));
        }
    }
};

int main() {
    ba::io_context io_context;
    auto work_guard = make_work_guard(io_context);

    boost::thread_group vth;

    auto mw = [&io_context] {
        TRACE("Thread Start");

        while (true) {
            try {
                io_context.run();
                break; // normal end
            } catch (boost::system::system_error const& se) {
                TRACE("MyWorker: received an error: " << se.code().message());
            } catch (std::exception const& ex) {
                TRACE("MyWorker: caught an exception: " << ex.what());
            }
        }

        TRACE("Thread Finish");
    };

    vth.create_thread(mw);

    try {
        std::make_shared<Client>(io_context)->Start();

        char t;
        std::cin >> t;
        work_guard.reset();
    } catch (std::exception const& ex) {
        TRACE("Main Thread: caught an exception: " << ex.what());
    }

    vth.join_all();
}

打印:

[140095938852608] Thread Start
[140095938852608] OnConnect ep:95.165.130.37:80
[140095938852608] "GET / HTTP/1.1
Host: unegare.info

"
[140095938852608] OnSend
[140095938852608] OnRecv
[140095938852608] "HTTP/1.1 200 OK
Date: Sun, 22 Dec 2019 22:26:56 GMT
Server: Apache/2.4.18 (Ubuntu)
Last-Modified: Sun, 10 Mar 2019 10:17:38 GMT
ETag: \"37-583bac3f3c843\"
Accept-Ranges: bytes
Content-Length: 55
Content-Type: text/html

<html>
<head>
</head>
<body>
It works.
</body>
</html>
"
q
[140095938852608] Thread Finish

奖金
std::bind自 C++11 以来已过时，请考虑改用 lambda。由于 Coliru 不想再合作，所以我将完整发布三个更改的功能:

void Start() {
    tcp::resolver resolver(io_context);
    ba::async_connect(sock,
        resolver.resolve({"unegare.info", "80"}),
        [self=shared_from_this()](error_code ec, tcp::endpoint) { self->OnConnect(ec); });
}

void OnConnect(const boost::system::error_code& ec) {
    TRACE(__FUNCTION__ << " ep:" << sock.remote_endpoint());
    if (ec) {
        TRACE(__FUNCTION__ << ": " << ec.message());
    } else {
        buf = "GET / HTTP/1.1\r\nHost: unegare.info\r\n\r\n";
        TRACE(std::quoted(buf));
        sock.async_write_some(ba::buffer(buf),
            [self=shared_from_this()](error_code ec, size_t bytes_transferred) { self->OnSend(ec, bytes_transferred); });
    }
}

void OnSend(const boost::system::error_code& ec, std::size_t bytes_transferred) {
    if (ec) {
        TRACE(__FUNCTION__ << ": " << ec.message() << " and bytes_transferred: " << bytes_transferred);
    } else {
        TRACE(__FUNCTION__);
        buf.assign(512, '\0');
        sock.async_read_some(ba::buffer(buf), 
            [self=shared_from_this()](error_code ec, size_t bytes_transferred) { self->OnRecv(ec, bytes_transferred); });
    }
}

¹ Does boost::bind() copy parameters by reference or by value?

² Coliru 不允许网络访问

关于c++ - 在调用 std::bind 的乘积后意外调用析构函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/59448138/

文章推荐： java - 执行递归时出现 Stackoverflow

文章推荐： java - 登录 Servlet 直接变为 False

文章推荐： c++ - 如何打印我在 map 中使用的数组？

Javascript AJAX 调用 Jquery 调用
为了让我的代码几乎完全用 Jquery 编写，我想用 Jquery 重写 AJAX 调用。这是从网页到 Tomcat servlet 的调用。我目前情况的类似代码: var http = new
Java 调用 C 调用 Java
我想使用 JNI 从 Java 调用 C 函数。在 C 函数中，我想创建一个 JVM 并调用一些 Java 对象。当我尝试创建 JVM 时，JNI_CreateJavaVM 返回 -1。所以，我想知
javascript - 调用 javascript 函数以从无法按预期工作的表单进行 AJAX 调用
环顾四周，我发现从 HTML 调用 Javascript 函数的最佳方法是将函数本身放在 HTML 中，而不是外部 Javascript 文件。所以我一直在网上四处寻找，找到了一些简短的教程，我可以根
ajax - 为什么我不能从 Angular 调用 ajax 调用
我有这个组件: import {Component} from 'angular2/core'; import {UserServices} from '../services/UserService
openssl - 如果客户端使用 BIO_* 调用，是否需要服务器上的 BIO_* 调用？
我正在尝试用 C 实现一个简单的 OpenSSL 客户端/服务器模型，并且对 BIO_* 调用的使用感到好奇，与原始 SSL_* 调用相比，它允许一些不错的功能。我对此比较陌生，所以我可能会完全错误
javascript - 根据先前的 Ajax 调用，根据用户确认执行 Ajax 调用
我正在处理有关异步调用的难题: 一个 JQuery 函数在用户点击时执行，然后调用一个 php 文件来检查用户输入是否与数据库中已有的信息重叠。如果是这样，则应提示用户确认是否要继续或取消，如果他单击
java - 验证私有(private)构造函数未使用 JMockit 调用/调用
我有以下类(class)。 public Task { public static Task getInstance(String taskName) { return new
c++ - 调用 QSound 调用，它们之间有延迟 Qt C++
嘿，我正在构建一个小游戏，我正在通过制作一个数字 vector 来创建关卡，该数字 vector 通过枚举与 1-4 种颜色相关联。问题是循环(在 Simon::loadChallenge 中)我将颜
Java 异步 api 调用 - 即发即忘 http 调用
我有一个java spring boot api(数据接收器)，客户端调用它来保存一些数据。一旦我完成了数据的持久化，我想进行另一个 api 调用(应该处理持久化的数据 - 数据聚合器)，它应该自行异
c# - 如何从 Paypal 调用 DoDirectPayment API 调用
首先，这涉及桌面应用程序而不是 ASP .Net 应用程序。我已经为我的项目添加了一个 Web 引用，并构建了各种数据对象，例如 PayerInfo、Address 和 CreditCard。但问题
f# - 如何从 FAKE 调用/调用 F# 编译器 fsc？
我如何告诉 FAKE 编译 .fs文件使用 fsc ? 解释如何传递参数的奖励积分，如 -a和 -target:dll . 编辑:我应该澄清一下，我正在尝试在没有 MSBuild/xbuild/.sl
javascript - render 没有被一个 api 调用，而是被另一个 api 调用
我使用下划线模板配置了一个简单的主干模型和 View 。两个单独的 API 使用完全相同的配置。 API 1 按预期工作。要重现该问题，请注释掉 API 1 的 URL，并取消注释 API 2 的
php - OOP 或 MySQL 调用。生成对象还是直接从 MySQL 调用？
我不确定什么是更好的做法或更现实的做法。我希望从头开始创建目录系统，但不确定最佳方法是什么。我想我在需要显示信息时使用对象，例如 info.php?id=100。有这样的代码用于显示 Game.cl
python - child 调用 parent ， parent 调用 child ......或不
from datetime import timedelta class A: def __abs__(self): return -self class B1(A):
java - 调用/调用 void 方法(Java 作业 - 生命游戏示例)
我在操作此生命游戏示例代码中的数组时遇到问题。情况: “生命游戏”是约翰·康威发明的一种细胞自动化技术。它由一个细胞网格组成，这些细胞可以根据数学规则生存/死亡/繁殖。该网格中的活细胞和死细胞通过
调用 read() 返回 0 但缓冲区已更改，调用 fread() 读取相同偏移量时不会发生
如果我像这样调用 read() 来读取文件: unsigned char buf[512]; memset(buf, 0, sizeof(unsigned char) * 512); int fd;
调用 "start"启动程序，调用 "stop"关闭 C 中的当前实例
我用 C 编写了一个简单的服务器，并希望调用它的功能与调用其他 C 守护程序的功能相同(例如使用 ./ftpd start 调用它并使用 ./ftpd stop 关闭该实例)。显然我遇到的问题是我不知
powershell - 可以从 cmd 调用 headless，但不能从 powershell 调用 headless
在 dos 中，当我粘贴此命令时它会起作用: "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" https://google.
powershell - 可以从 cmd 调用 headless，但不能从 powershell 调用 headless
在 dos 中，当我粘贴此命令时它会起作用: "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" https://google.
python - 调用 python3 显示错误，调用 python 启动 python2.7
我希望能够从 cmd 在我的 Windows 10 计算机上调用 python3。我已重新安装 Python3.7 以确保选择“添加到路径”选项，但仍无法调用 python3 并使 CMD 启动 P

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - 在调用 std::bind 的乘积后意外调用析构函数