boost:：asio async\u接受kill ioservice

你能帮我解决这个小问题吗

我有两门课： 表格1 异步srv

启动应用程序时，Form1将创建异步\u srv实例。 听着我的套接字，所有人都收到了发送到主类的数据，并从她那里返回了答案。 当get-1时，我需要destoy接受程序/服务/线程和我的应用程序。 但这不会发生。 有什么建议吗

我的async_srv.h

#include "Form1.h"
#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
typedef boost::shared_ptr<boost::asio::ip::tcp::socket> socket_ptr;
typedef boost::shared_ptr<boost::asio::ip::tcp::acceptor> acc_ptr;


class async_srv
{
    private:
    boost::thread* srv_thread;
    boost::asio::streambuf response;
    std::stringstream s;
    int stop;
    TForm* ourForm;
    boost::shared_ptr<boost::asio::io_service> m_ioservice;

    protected:
    void start();
    void start_accept(acc_ptr acc,socket_ptr sock);
    void handle_accept(acc_ptr acc, socket_ptr sock);

    public:
    __fastcall async_srv(TForm* Form1);
    void kill(); 

};

#包括“Form1.h”
#包括
#包括
#包括
typedef boost:：共享的\u ptr套接字\u ptr；
typedef boost：：共享\u ptr acc\u ptr；
类异步\u srv
{
私人：
boost：：线程*srv_线程；
boost:：asio:：streambuf响应；
std:：strings；
int stop；
TForm*ourForm；
boost：：共享的ptr m_ioservice；
受保护的：
void start（）；
无效启动和接受（附件、插座和插座）；
无效手柄接受（附件、插座、插座）；
公众：
__fastcall async_srv（TForm*Form1）；
无效杀死（）；
};

我的async_srv.cpp

fastcall async_srv::async_srv(TForm* Form1): m_ioservice(boost::make_shared<boost::asio::io_service>())
{
 //create Pointer to main form
ourForm = Form1;
 //create thread to async recieve for realease this class
srv_thread = new boost::thread(boost::bind(&async_srv::start, this));
}

void async_srv::start()
{
 //create acceptor, and socket.
acc_ptr acc(new boost::asio::ip::tcp::acceptor(*m_ioservice, ep));
socket_ptr sock(new boost::asio::ip::tcp::socket(*m_ioservice));

//start_accept
start_accept(acc,sock);
m_ioservice->run();
}

void async_srv::start_accept(acc_ptr acc,socket_ptr sock)
{
  // async accept
  acc->async_accept(*sock, boost::bind(&async_srv::handle_accept, this, acc, sock));
}

void async_srv::handle_accept(acc_ptr acc, socket_ptr sock)
{
    //loop for recieve data
    while (boost::asio::read(*sock, response, boost::asio::transfer_at_least(1), error))
    s << &response;

    if (s.str() != "")
      {
       //recieve answer from main
      stop = ourForm->update(s.str());
         if(stop == -1)
                  {
                               //kill our class and application
                  acc->close();
                  kill();
                  Application->Terminate();
                  return;
                  }
      }

    s.str(std::string());
    response.consume(response.size());
    start_accept(acc,sock);
}

void async_srv::kill()
{
m_ioservice->stop();
srv_thread->~thread();
}

fastcall async\u srv:：async\u srv（TForm*Form1）：m\u ioservice（boost:：make\u shared（））
{
//创建指向主窗体的指针
我们的形式=形式1；
//为realease类创建异步接收线程
srv_-thread=newboost:：thread（boost:：bind（&async_-srv:：start，this））；
}
void async_srv:：start（）
{
//创建接受程序和套接字。
acc_ptr acc（新的boost:：asio:：ip:：tcp:：acceptor（*m_ioservice，ep））；
socket_ptr sock（新的boost:：asio:：ip:：tcp:：socket（*m_ioservice））；
//开始接受
开始接受（acc、sock）；
m_ioservice->run（）；
}
void async_srv:：start_accept（acc_ptr acc，socket_ptr sock）
{
//异步接受
acc->async_accept（*sock，boost:：bind（&async_srv:：handle_accept，this，acc，sock））；
}
void async_srv:：handle_accept（acc_ptr acc，socket_ptr sock）
{
//接收数据的循环
while（boost:：asio:：read（*sock，response，boost:：asio:：transfer_至少（1），错误））
s更新（s.str（））；
如果（停止==-1）
{
//杀死我们的类和应用程序
acc->close（）；
杀死（）；
应用程序->终止（）；
返回；
}
}
s、 str（std:：string（））；
response.consume（response.size（））；
开始接受（acc、sock）；
}
void async_srv:：kill（）
{
m_ioservice->stop（）；
srv_线程->~thread（）；
}

如果要停止接受新连接，请将接受者设置为成员，并在需要时关闭它：

void async_srv::kill()
{
  // avoid closing from another thread
  m_acceptor.get_io_service().post(()[this] { m_acceptor->close(); });
}

---

如果

m\u ioservice

仅为接受者提供服务，关闭它将断开

async\u accept-->handle\u accept-->…

链，并最终使

m\u ioservice:：run（）

退出，因为它已无法工作。（当然，您不应该调用

~thread

）

手动调用

srv_thread

的析构函数听起来是个非常糟糕的主意。另外，由于目前尚不清楚您的

async\u src

类是如何使用的，您是否可以发布一条消息。杀死线程不是主要问题，我可以使用interupption而不是析构函数。主要问题是，服务未停止接受用于从tcp/ip套接字接收数据的aftser stop（）async\u src。是否确定正在调用

kill（）

？只要看一下代码，如果

sock

在没有任何数据的情况下关闭，或者

ourForm->update（）

在链中第一次调用它时返回除

-1

以外的任何值，那么

start\u accept（）

和

handle\u accept（）之间就会形成一个紧密的异步链

由于操作失败，因为

sock

的状态。accept操作将立即失败，因为

sock

已打开，而read操作将立即失败，因为文件已结束，将

s.str（）

留空，并且不再查询表单。我的错误是在我的句柄上调用start\u accept方法，只需替换“start\u accept（acc，sock）”以创建新的“async->accept”，我用的是boost 1.39，我的接受者没有方法get\u io\u service（）@user2393500它被称为

io\u service（）

。我知道，对不起我的错误。IDE不会在提示中显示此方法。我已经关闭了接受程序：if（stop=-1）{acc->close（）；kill（）；Application->Terminate（）；}@user2393500我想问题出在代码的其他地方。在调试器中尝试并调试它-设置断点，单步执行代码等。