Question

我有一个创建新桥对象并将其存储为boost :: shared_ptr：

的函数。

bool proxy::bridge::acceptor::accept_connections() {
    try {
        session_ = boost::shared_ptr<bridge>(new bridge(io_service_));

        acceptor_.async_accept(session_->downstream_socket(),
            boost::bind(&acceptor::handle_accept,
                this, boost::asio::placeholders::error));
    }
    catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
        return false;
    }

return true;
}

void proxy::bridge::acceptor::handle_accept(const boost::system::error_code& error) {
    if (!error) {
        session_->local_connect();
        if (!accept_connections()) {
        }
    }
    else {
        std::cerr << error.message() << std::endl;
    }
}

bridge类中的std :: future变量在标头中定义并在bridge类方法中初始化：

//proxy.h
std::mutex add_data_lock;
std::vector<int> global_resource_protected_by_lock;

class proxy {
    //...
    class bridge {
        //...
        std::future<void> f_read;
    };

    class acceptor {
         //...
    };
};

//proxy.cpp
void proxy::bridge::read(const boost::system::error_code& error, const size_t& bytes_transferred) {
    if (!error) {
        if (f_read.valid()) { f_read.wait(); }
        f_read = std::async(std::launch::async, std::bind(&proxy::bridge::handle_add_data, shared_from_this(), bytes_transferred));
    }
    else {
        close();
    }
}

void proxy::bridge::handle_add_data(const size_t& bytes_transferred) {
    add_data_lock.lock();
    //do work here
    add_data_lock.unlock();
}

void proxy::bridge::close() {
    //this is called when this object is no longer useful (ie. connection closed)

    if (f_read.valid()) { f_read.wait(); }

    //other closing functions...
}

read（）方法被重复调用-目标是异步调用handle_add_data（）并在read（）的两个周期之间进行工作。

但是，即使关闭套接字，动态创建的桥对象也不会被删除（进程占用越来越多的内存）。

如果我将异步调用和future替换为对handle_add_data（）的直接函数调用，则在调用close（）时，所有内容都将正确释放。

如果我将f_read future作为具有文件作用域的静态变量移到类之外，那么所有内容也都被正确释放，但有时会出现“忙时销毁互斥体”错误。

如果我不将异步调用分配给任何东西，那么当超出函数范围时，它将阻塞，从而达不到使用它的目的。

我应该怎么做才能在调用close（）之后正确删除动态创建的桥对象？

对于混乱的代码，我们深表歉意-我尽可能地精简了一下，以说明问题。

Answer 1

您的bind保持shared_ptr的时间比需要的时间长。您可以对其进行更改，以在完成后显式释放捕获的指针。

f_read = std::async(std::launch::async, [=, self = shared_from_this()]() mutable { self->handle_add_data(bytes_transferred); self = nullptr; });

在C ++ 14之前，您需要初始化为被捕获的本地

auto self = shared_from_this();
f_read = std::async(std::launch::async, [=]() mutable { self->handle_add_data(bytes_transferred); self = nullptr; });

成员std :: future防止boost :: shared_ptr超出范围

1 个答案: