我的应用程序基于asio聊天示例，由客户端和服务器组成： - 客户端：连接到服务器，接收请求并对其进行响应 - 服务器：具有QT GUI（主线程）和网络服务（单独线程），用于监听连接，向特定客户端发送请求以及解释来自GUI中的响应
我希望以异步方式实现此目的，以避免每个客户端连接的单独线程。
在我的QT窗口中，我有一个will not get the physical file in server side实例和一个网络服务实例：
io_service我希望能够将数据发送到一个客户端，如下所示：
io_service_ = new asio::io_service();
asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), "1234");
service_ = new Service(*io_service_, endpoint, this);
asio::io_service* ioServicePointer = io_service_;
t = std::thread{ [ioServicePointer](){ ioServicePointer->run(); } };
我通过观察者模式接收和处理响应（窗口实现了IStreamListener接口）
Service.cpp：
service_->send_message(selectedClient.id, msg);
Stream.cpp：
#include "Service.h"
#include "Stream.h"
void Service::runAcceptor()
{
acceptor_.async_accept(socket_,
[this](asio::error_code ec)
{
if (!ec)
{
std::make_shared<Stream>(std::move(socket_), &streams_)->start();
}
runAcceptor();
});
}
void Service::send_message(std::string streamID, chat_message& msg)
{
io_service_.post(
[this, msg, streamID]()
{
auto stream = streams_.getStreamByID(streamID);
stream->deliver(msg);
});
}
接口
#include "Stream.h"
#include <iostream>
#include "../chat_message.h"
Stream::Stream(asio::ip::tcp::socket socket, StreamCollection* streams)
: socket_(std::move(socket))
{
streams_ = streams; // keep a reference to the streamCollection
// retrieve endpoint ip
asio::ip::tcp::endpoint remote_ep = socket_.remote_endpoint();
asio::ip::address remote_ad = remote_ep.address();
this->ip_ = remote_ad.to_string();
}
void Stream::start()
{
streams_->join(shared_from_this());
readHeader();
}
void Stream::deliver(const chat_message& msg)
{
bool write_in_progress = !write_msgs_.empty();
write_msgs_.push_back(msg);
if (!write_in_progress)
{
write();
}
}
std::string Stream::getName()
{
return name_;
}
std::string Stream::getIP()
{
return ip_;
}
void Stream::RegisterListener(IStreamListener *l)
{
m_listeners.insert(l);
}
void Stream::UnregisterListener(IStreamListener *l)
{
std::set<IStreamListener *>::const_iterator iter = m_listeners.find(l);
if (iter != m_listeners.end())
{
m_listeners.erase(iter);
}
else {
std::cerr << "Could not unregister the specified listener object as it is not registered." << std::endl;
}
}
void Stream::readHeader()
{
auto self(shared_from_this());
asio::async_read(socket_,
asio::buffer(read_msg_.data(), chat_message::header_length),
[this, self](asio::error_code ec, std::size_t /*length*/)
{
if (!ec && read_msg_.decode_header())
{
readBody();
}
else if (ec == asio::error::eof || ec == asio::error::connection_reset)
{
std::for_each(m_listeners.begin(), m_listeners.end(), [&](IStreamListener *l) {l->onStreamDisconnecting(this->id()); });
streams_->die(shared_from_this());
}
else
{
std::cerr << "Exception: " << ec.message();
}
});
}
void Stream::readBody()
{
auto self(shared_from_this());
asio::async_read(socket_,
asio::buffer(read_msg_.body(), read_msg_.body_length()),
[this, self](asio::error_code ec, std::size_t /*length*/)
{
if (!ec)
{
// notify the listener (GUI) that a response has arrived and pass a reference to it
auto msg = std::make_shared<chat_message>(std::move(read_msg_));
std::for_each(m_listeners.begin(), m_listeners.end(), [&](IStreamListener *l) {l->onMessageReceived(msg); });
readHeader();
}
else
{
streams_->die(shared_from_this());
}
});
}
void Stream::write()
{
auto self(shared_from_this());
asio::async_write(socket_,
asio::buffer(write_msgs_.front().data(),
write_msgs_.front().length()),
[this, self](asio::error_code ec, std::size_t /*length*/)
{
if (!ec)
{
write_msgs_.pop_front();
if (!write_msgs_.empty())
{
write();
}
}
else
{
streams_->die(shared_from_this());
}
});
}
StreamCollection基本上是一组IStream：
class IStream
{
public:
/// Unique stream identifier
typedef void* TId;
virtual TId id() const
{
return (TId)(this);
}
virtual ~IStream() {}
virtual void deliver(const chat_message& msg) = 0;
virtual std::string getName() = 0;
virtual std::string getIP() = 0;
/// observer pattern
virtual void RegisterListener(IStreamListener *l) = 0;
virtual void UnregisterListener(IStreamListener *l) = 0;
};
class IStreamListener
{
public:
virtual void onStreamDisconnecting(IStream::TId streamId) = 0;
virtual void onMessageReceived(std::shared_ptr<chat_message> msg) = 0;
};
/*
streamCollection / service delegates
*/
class IStreamCollectionListener
{
public:
virtual void onStreamDied(IStream::TId streamId) = 0;
virtual void onStreamCreated(std::shared_ptr<IStream> stream) = 0;
};
首先：代码到目前为止按预期工作。
我的问题：
这是ASIO应该用于异步编程的方式吗？我对 class StreamCollection
{
public:
void join(stream_ptr stream)
{
streams_.insert(stream);
std::for_each(m_listeners.begin(), m_listeners.end(), [&](IStreamCollectionListener *l) {l->onStreamCreated(stream); });
}
// more events and observer pattern inplementation
方法和Service::send_message的使用特别不确定。在我的情况下，它的目的是什么？当我刚刚调用async_write时它也没有将它包装在io_service.post调用中。
我是否遇到过这种方法的问题？
答案 0 :(得分：2)
Asio designed是一个简单而不是框架。因此，有多种方法可以成功使用它。分离GUI和网络线程，并使用异步I / O实现可伸缩性是一个好主意。
将工作委托给公共API中的io_service，例如Service::send_message()，会产生以下后果：
io_service提供服务的线程分离。例如，如果Stream::write()执行耗时的加密功能，则调用程序线程（GUI）不会受到影响。io_service是线程安全的;但是socket不是线程安全的。此外，其他对象可能不是线程安全的，例如write_msgs_。 Asio保证只能在运行io_servce的线程中调用处理程序。因此，如果只有一个线程正在运行io_service，那么就不可能实现并发，并且将以线程安全的方式访问socket_和write_msgs_。 Asio将此称为隐式 strand。如果多个线程正在处理io_service，则可能需要使用显式strand来提供线程安全性。有关股票的详细信息，请参阅this答案。其他Asio注意事项：
在处理程序中调用观察者，处理程序在网络线程中运行。如果任何观察者需要很长时间才能完成，例如必须与GUI线程触及的各种共享对象同步，那么它可能会在其他操作中产生较差的响应。考虑使用队列来代理 observer 和 subject 组件之间的事件。例如，可以使用另一个io_service作为队列，由其自己的线程运行，并发布到其中：
auto msg = std::make_shared<chat_message>(std::move(read_msg_));
for (auto l: m_listeners)
dispatch_io_service.post([=](){ l->onMessageReceived(msg); });
验证write_msgs_的容器类型不会使push_back()上的现有元素的迭代器，指针和引用以及pop_front()的其他元素无效。例如，使用std::list或std::dequeue是安全的，但std::vector可能会使对push_back上现有元素的引用无效。
StreamCollection::die()，可以多次调用Stream。此功能应该是幂等的或适当地处理副作用。Stream失败，则只会在一个路径中通知其侦听器断开连接：未能读取错误为asio::error::eof或asio::error::connection_reset的标头。其他路径不会调用IStreamListener.onStreamDisconnecting()：
std::cerr的打印声明。