Networking 未调用asio tcp async_accept处理程序，但同步连接工作正常

我有一个TCP客户机，在其中调用TCP套接字上的常规连接可以正常工作。但是，对async_connect的调用从不触发处理程序。它们都使用几乎相同的代码。区别在于调用connect与async_connect

标题

#ifndef TCPCLIENT_H
#define TCPCLIENT_H

#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>

#include <boost/thread/thread.hpp> 
#include <boost/thread/mutex.hpp>

using boost::asio::ip::tcp;

//How about an interface for outputting errors
class BoostTCPDebugOutputInterface
{
public:
    virtual void outputError(std::string& error)=0;
    virtual void outputDebug(std::string& debug) = 0;
    virtual void outputWarning(std::string& warning) = 0;
    virtual void outputInfo(std::string& info) = 0;

};

class ShutdownCallback
{
public:
    virtual void shutdown() = 0;
};

class BoostTCPConnection 
    : public boost::enable_shared_from_this<BoostTCPConnection>
{
public:
    typedef boost::shared_ptr<BoostTCPConnection> Connection_ptr;

    static Connection_ptr create(boost::asio::io_service& io_service, BoostTCPDebugOutputInterface* output, ShutdownCallback* shutdowner)
    {
        return Connection_ptr(new BoostTCPConnection(io_service, output, shutdowner));
    }

    virtual ~BoostTCPConnection(void);

    void start();
    bool isRunning();
    void setRunning(bool running);

    void enqueueMessageToSend(boost::shared_ptr<std::string>& message);

    boost::asio::ip::tcp::socket& socket()
    {
        return socket_;
    }

    void getQueueSize(unsigned long& tcpToSend, unsigned long& tcpRead);

    void getMessages(std::list< boost::shared_ptr<std::string> >& messages);

protected:
    BoostTCPConnection(boost::asio::io_service& io_service, BoostTCPDebugOutputInterface* output, ShutdownCallback* shutdowner) : socket_(io_service), errorOutput_(output), shutdowner_(shutdowner) {}

    void send();
    void handleWrite(const boost::system::error_code& error,size_t bytes_transferred);
    void handleReceive(const boost::system::error_code& error,size_t bytes_transferred);

    void readMessage();
    void handleReceive();

    std::string hostIP_;
    unsigned int hostPort_;

    boost::asio::io_service io_service_;
    boost::asio::ip::tcp::socket socket_;

    boost::mutex runningMutex_;
    bool running_;

    boost::mutex readMutex_;
    std::list< boost::shared_ptr<std::string> > receivedMsgs_;

    boost::mutex sendMutex_;
    std::list< boost::shared_ptr<std::string> > sendMsgs_;

    BoostTCPDebugOutputInterface* errorOutput_;
    ShutdownCallback* shutdowner_;

    static const size_t HEADERSIZE = 4;
};

class TCPClient
{
public:
    TCPClient();
    virtual ~TCPClient();

    bool start(std::string& hostIP,  unsigned int& hostPort, BoostTCPDebugOutputInterface* output, ShutdownCallback* shutdowner);
    void stop();

    void getQueueSize(unsigned long& tcpToSend, unsigned long& tcpRead);

    void send(boost::shared_ptr<std::string>& message);
    void getMessages(std::list< boost::shared_ptr<std::string> >& messages);

protected:
    void threadAction();

    void handleConnect(const boost::system::error_code& error);


    BoostTCPConnection::Connection_ptr connection_;

    boost::thread_group worker_threads_;

    boost::asio::io_service io_service_;

    BoostTCPDebugOutputInterface* errorOutput_;
    ShutdownCallback* shutdowner_;
};

#endif

\ifndef TCPCLIENT\u H
#定义TCPCLIENT\u H
#包括
#包括
#包括
#包括
#包括
#包括
使用boost:：asio:：ip:：tcp；
//一个输出错误的接口怎么样
类BoostTCPDebugOutputInterface
{
公众：
虚空输出器（标准：：字符串和错误）=0；
虚拟void outputDebug（std:：string&debug）=0；
虚空输出警告（std:：string&warning）=0；
虚空输出信息（std:：string&info）=0；
};
类关闭回调
{
公众：
虚空关闭（）=0；
};
类boosttcp连接
：public boost：：从\u启用\u共享\u
{
公众：
typedef boost：：共享\u ptr连接\u ptr；
静态连接\u ptr创建（boost:：asio:：io\u服务和io\u服务，BoostTCPDebugOutputInterface*输出，ShutdownCallback*关闭器）
{
返回连接（新的boosttcp连接（io_服务、输出、关机））；
}
虚拟~boosttcp连接（void）；
void start（）；
布尔正在运行（）；
无效设置运行（bool运行）；
void enqueueMessageToSend（boost:：shared_ptr&message）；
boost:：asio:：ip:：tcp:：socket和socket（）
{
返回插座；
}
void getQueueSize（未签名的long和tcpToSend，未签名的long和tcpRead）；
void getMessages（std:：list&消息）；
受保护的：
boosttcpcconnection（boost:：asio:：io_服务&io_服务，BoostTCPDebugOutputInterface*输出，ShutdownCallback*关闭器）：socket_（io_服务），errorOutput_（输出），shutdowner_（关闭器）{}
无效发送（）；
void handleWrite（const boost:：system:：error\u code&error，size\u t bytes\u transfer）；
void handleReceive（const boost:：system:：error\u code&error，size\u t bytes\u transfer）；
void readMessage（）；
void handleReceive（）；
std：：字符串hostIP；
未签名的int主机端口；
boost:：asio:：io_服务io_服务；
boost:：asio:：ip:：tcp:：socket；
boost:：mutex runningMutex；
布尔跑步；
boost:：mutex readMutex；
std:：listreceivedMsgs；
boost：：互斥发送互斥；
std:：listsendMsgs；
BoostTCPDebugOutputInterface*错误输出；
关机回调*关机器；
静态const size\u t HEADERSIZE=4；
};
类TCPClient
{
公众：
TCPClient（）；
虚拟~TCPClient（）；
bool启动（std:：string和hostIP、unsigned int和hostPort、BoostTCPDebugOutputInterface*输出、ShutdownCallback*关闭器）；
无效停止（）；
void getQueueSize（未签名的long和tcpToSend，未签名的long和tcpRead）；
无效发送（boost：：共享消息和消息）；
void getMessages（std:：list&消息）；
受保护的：
void threadAction（）；
void handleConnect（const boost:：system:：error\u code&error）；
BoostTCPConnection:：Connection\u ptr Connection；
boost：：线程\u组工作线程\u；
boost:：asio:：io_服务io_服务；
BoostTCPDebugOutputInterface*错误输出；
关机回调*关机器；
};
#恩迪夫

CPP文件

#include "TCPClient.h"

#include <iostream>

BoostTCPConnection::~BoostTCPConnection(void)
{
}

void BoostTCPConnection::start()
{
    setRunning(true);
    while (isRunning())
    {

        bool readData(false);
        bool wroteData(false);

        if (!socket_.is_open())
        {
            std::string info("BoostTCPConnection::start() socket is no longer open.  ");
            errorOutput_->outputError(info);
            shutdowner_->shutdown();
            //Stop this NOW!!!
        }

        //Check if there are 4 bytes for packet size 
        //If there are read the size and then do an read to get the packet
        //The handler function should put the packet on a queue.
        boost::asio::socket_base::bytes_readable command(true);

        socket_.io_control(command);
        std::size_t bytes_readable = command.get();

        if ( bytes_readable >= HEADERSIZE )
        {
            readMessage();
            readData=true;
        }

        size_t sendSize(0);
        {
            boost::mutex::scoped_lock(sendMutex_);
            sendSize = sendMsgs_.size();
        }

        if ( sendSize > 0)
        {
            send();
        }


        if ( !readData && !wroteData )
            boost::this_thread::sleep(boost::posix_time::milliseconds(5)); 
    }
}

void BoostTCPConnection::readMessage()
{
    size_t messageSize(0);

    char temp[4]="";
    std::vector<char> header(4);

    boost::system::error_code ec;

    //Read the header which is the size
    size_t read=boost::asio::read(socket_, boost::asio::buffer(header), ec);
    if (ec)
    {       
        std::string info("BoostTCPConnection::readMessage errorcode ");
        info+=ec.message();
        errorOutput_->outputError(info);
        shutdowner_->shutdown();
        //TODO Signal the GUI to stop
        return;
    }
    memcpy((void*)(&messageSize),(void*)header.data(),4);

    std::vector<char> rcvBuffer(messageSize);

    read=boost::asio::read(socket_, boost::asio::buffer(rcvBuffer),ec);
    if (ec)
    {

        std::string info("BoostTCPConnection::readMessage errorcode ");
        info+=ec.message();
        errorOutput_->outputError(info);
        shutdowner_->shutdown();
        //TODO Signal the GUI to stop
        return;
    }

    rcvBuffer.push_back('\0');

    std::string test(rcvBuffer.begin(),rcvBuffer.end());
    boost::shared_ptr<std::string> message(new std::string(rcvBuffer.begin(),rcvBuffer.end()));

    receivedMsgs_.push_back(message);

}

void BoostTCPConnection::getMessages(std::list< boost::shared_ptr<std::string> >& messages)
{

    if (messages.size() > 0)
        messages.clear();

    {
        boost::mutex::scoped_lock lock(readMutex_); 
        receivedMsgs_.swap(messages);
    }
}

void BoostTCPConnection::handleReceive(const boost::system::error_code& error, size_t bytes_transferred)
{

    if (error)
    {
        std::ostringstream oss;
        oss<< "BoostTCPConnection::handleReceive got an error Code of "<<error.value()<<" and message "<<error.message()<<" bytes_transferred = "<<bytes_transferred<<std::endl;
        errorOutput_->outputError(oss.str());
        shutdowner_->shutdown();
        return;
    }

}


bool BoostTCPConnection::isRunning()
{
    boost::mutex::scoped_lock lock(runningMutex_);
    return running_;
}

void BoostTCPConnection::setRunning(bool running)
{
    boost::mutex::scoped_lock lock(runningMutex_);
    running_=running;
}

void BoostTCPConnection::enqueueMessageToSend(boost::shared_ptr<std::string>& message)
{
    boost::mutex::scoped_lock lock(sendMutex_);
    sendMsgs_.push_back(message);
}

void BoostTCPConnection::getQueueSize(unsigned long& tcpToSend, unsigned long& tcpRead)
{
    {
        boost::mutex::scoped_lock lock(sendMutex_);
        tcpToSend=sendMsgs_.size();
    }

    {
        boost::mutex::scoped_lock lock(readMutex_);
        tcpRead=receivedMsgs_.size();
    }

}


void BoostTCPConnection::send()
{
    if (sendMsgs_.empty())
        return;

    boost::shared_ptr<std::string> message;
    {
        message=sendMsgs_.front();
        sendMsgs_.pop_front();
    }

    char temp[4];
    size_t messageSize=message->size();
    memcpy(temp,&messageSize, 4);

    message->insert(0,temp, 4);

    boost::asio::async_write(socket_, boost::asio::buffer(*message),
        boost::bind(&BoostTCPConnection::handleWrite, shared_from_this(),
        boost::asio::placeholders::error,
        boost::asio::placeholders::bytes_transferred));

}

void BoostTCPConnection::handleWrite(const boost::system::error_code& error,size_t bytes_transferred)
{
    //Success
    if (error.value() == 0) 
        return;

    std::ostringstream oss;
    oss<< "BoostTCPConnection::handleWrite  got an error Code of "<<error.value()<<" and message "<<error.message()<<" with bytes_transferred = "<<bytes_transferred<<std::endl;
    errorOutput_->outputError(oss.str());
    shutdowner_->shutdown();

}

//***************************************************
//              TCPClient
//***************************************************

TCPClient::TCPClient()
{

}

TCPClient::~TCPClient()
{

}

void TCPClient::threadAction()
{
    io_service_.run();
}

bool TCPClient::start(std::string& hostIP,  unsigned int& hostPort, BoostTCPDebugOutputInterface* output, ShutdownCallback* shutdowner)
{
    bool bResult(false);
    errorOutput_=output;
    connection_ = BoostTCPConnection::create(io_service_, output, shutdowner);
    shutdowner_=shutdowner;

    //Use multiple threads to do my bidding
    for( int x = 0; x < 3; ++x )
    {
        worker_threads_.create_thread( 
            boost::bind( &TCPClient::threadAction, this )
            );
    }

    boost::system::error_code ec;
    try
    {
        boost::asio::ip::tcp::endpoint ep( boost::asio::ip::address_v4::from_string(hostIP), hostPort);
        if (connection_)
        {


            connection_->socket().async_connect(ep,
                                                boost::bind(&TCPClient::handleConnect, 
                                                this, boost::asio::placeholders::error));

                            //Synchronous code that works fine
                            //boost::system::error_code ec;         
            //connection_->socket().connect(ep, ec);
            /*if (!ec)
            {
                worker_threads_.create_thread( 
                    boost::bind( &TCPClient::handleConnect, this, ec ));

                bResult=true;
            }
            else
            {
                std::ostringstream oss;
                oss<< "BoostTCPConnection::start has an error "<<ec.message()<<std::endl;
                errorOutput_->outputError(oss.str());

            }*/

        }
    }
    catch (std::exception& e)
    {
        std::ostringstream oss;
        oss<< "BoostTCPConnection::start received the exception "<<e.what()<<std::endl;
        errorOutput_->outputError(oss.str());
    }

    return bResult;
}

void TCPClient::handleConnect(const boost::system::error_code& error)
{

    if (error )
    {
        std::ostringstream oss;
        oss<< "BoostTCPConnection::handleConnect received the error "<<error.message()<<std::endl;
        errorOutput_->outputError(oss.str());
        shutdowner_->shutdown();
        return;
    }

    if (connection_)
        connection_->start();

}

void TCPClient::stop()
{
    if (connection_)
        connection_->setRunning(false);

    io_service_.stop();
    worker_threads_.join_all();
}

void TCPClient::getQueueSize(unsigned long& tcpToSend, unsigned long& tcpRead)
{
    if (connection_)
        connection_->getQueueSize(tcpToSend, tcpRead);
    else
    {
        tcpToSend=0;
        tcpRead=0;
    }
}

void TCPClient::send(boost::shared_ptr<std::string>& message)
{
    if (connection_)
        connection_->enqueueMessageToSend(message);
}

void TCPClient::getMessages(std::list< boost::shared_ptr<std::string> >& messages)
{ 
    if (connection_)
        connection_->getMessages(messages);
}

#包括“TCPClient.h”
#包括
BoostTCPConnection:：~BoostTCPConnection（void）
{
}
void boosttcpcconnection:：start（）
{
设置正在运行（真）；
while（isRunning（））
{
bool readData（假）；
bool wroteData（假）；
如果（！socket_u.is_open（））
{
std:：string info（“BoostTCPConnection:：start（）套接字不再打开”）；
错误输出->输出错误（信息）；
关机程序->关机（）；
//现在停止！！！
}
//检查数据包大小是否有4个字节
//如果存在读取大小，则执行读取以获取数据包
//处理函数应将数据包放入队列中。
boost:：asio:：socket\u base:：bytes\u可读命令（true）；
插座io控制（命令）；
std:：size\u t bytes\u readable=command.get（）；
如果（字节数可读>=标题大小）
{
readMessage（）；
readData=true；
}
大小\u t发送大小（0）；
{
boost:：mutex:：作用域锁定（sendMutex）；
sendSize=sendMsgs_u2;.size（）；
}
如果（发送大小>0）
{
send（）；
}
如果（！readData&&！wroteData）
boost：：this_线程：：sleep（boost：：posix_时间：：毫秒（5））；
}
}
void boosttcpcconnection:：readMessage（）
{
大小\u t消息大小（0）；
字符温度[4]=“”；
std：：向量头（4）；
boost:：system:：error_code ec；
//读取标题，它是大小
size\u t read=boost:：asio:：read（套接字，boost:：asio:：buffer（头），ec）；
国际单项体育联合会（欧共体）
{       
std:：string info（“BoostTCPConnection:：readMessage errorcode”）；
info+=ec.message（）；
错误输出->输出错误（信息）；
关机程序->关机（）；
//TODO向GUI发出停止的信号
返回；
}
memcpy（（void*）（&messageSize），（void*）header.data（），4）；
std：：向量rcvBuffer（messageSize）；
read=boost:：asio:：read（套接字），boost:：asio:：buffer（rcvBuffer），ec）；
国际单项体育联合会（欧共体）
{
std:：string info（“BoostTCPConnection:：readMessage errorcode”）；
info+=ec.message（）；
错误输出->输出错误（信息）；
关机程序->关机（）；
//TODO向GUI发出停止的信号
返回；
}
rcvBuffer.push_back（'\0'）；
字符串测试（rcvBuffer.begin（），rcvBuffer.end（））；
boost:：shared_ptr消息（新的std:：string（rcvBuffer.begin（），rcvBuffer.end（））；
接收DMSGs。推回（消息）；
}
void boosttcpcconnection:：getMessages（std:：list&消息）
{
如果（messages.size（）>0）
messages.clear（）；
{
boost:：mutex:：作用域锁定（readMutex）；
接收DMSGS交换（消息）；
}
}
void boosttcpcconnection:：hand
void TCPClient::threadAction() {
  io_service_.run();
  assert(0); // triggers right away because there's no async operation queued
}