1 接受数据
客户端与服务器建立连接，就有了一个TcpConnection对象，该TcpConnection对象包含客户端套接字文件描述符，对应的channel，以及所属的EventLoop对象。上述三个TcpConnection对象非常重要的数据成员，他们标识了这个TcpConnection对象的身份。TcpConnection对象还拥有inputBuffer_和outputBuffer_两个重要数据成员，用于接受数据和发送数据。
当事件循环收到可读事件的到来时，会调用fd对应的channel的读事件的回调函数ReadCallback_,这个回调函数在TcpConnection对象建立时便绑定在TcpConnection::handleRead函数上（见TcpConnection类的构造函数），因此可读事件触发TcpConnection::handleRead函数，如下：
void TcpConnection::handleRead(Timestamp receiveTime)
{
loop_->assertInLoopThread();
int savedErrno = 0;
//将读到的数据放入inputBuffer_中
ssize_t n = inputBuffer_.readFd(channel_->fd(), &savedErrno); //接受数据
if (n > 0) //读取n字节数据
{
messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
}
else if (n == 0) //对端关闭连接
{
handleClose();
}
else
{
errno = savedErrno;
LOG_SYSERR << "TcpConnection::handleRead";
handleError();
}
}
ssize_t Buffer::readFd(int fd, int* savedErrno)
{
// saved an ioctl()/FIONREAD call to tell how much to read
char extrabuf[65536]; //64k
struct iovec vec[2];
const size_t writable = writableBytes();
vec[0].iov_base = begin()+writerIndex_;
vec[0].iov_len = writable;
vec[1].iov_base = extrabuf;
vec[1].iov_len = sizeof extrabuf;
// when there is enough space in this buffer, don't read into extrabuf.
// when extrabuf is used, we read 128k-1 bytes at most.
const int iovcnt = (writable < sizeof extrabuf) ? 2 : 1;
const ssize_t n = sockets::readv(fd, vec, iovcnt);
if (n < 0)
{
*savedErrno = errno;
}
else if (implicit_cast<size_t>(n) <= writable) //还有剩余空间
{
writerIndex_ += n;
}
else //buffer中readable空间不够
{
writerIndex_ = buffer_.size();
append(extrabuf, n - writable);
}
// if (n == writable + sizeof extrabuf)
// {
// goto line_30;
// }
return n;
}
通过客户端fd读入数据，并将数据放入输入缓冲inputBuffer_中，当读取的字节n>0时，说明成功读取到了数据，因此调用用户回调函数来处理inputBuffer_中的数据。
messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
2 发送数据
发送数据是通过TcpConnection::send()函数和TcpConnection::handleWrite()函数进行。send函数如下：
void TcpConnection::send(const void* data, int len)
{
send(StringPiece(static_cast<const char*>(data), len));
}
void TcpConnection::send(const StringPiece& message)
{
if (state_ == kConnected)
{
if (loop_->isInLoopThread())
{
sendInLoop(message);
}
else
{
void (TcpConnection::*fp)(const StringPiece& message) = &TcpConnection::sendInLoop;
loop_->runInLoop(
std::bind(fp,
this, // FIXME
message.as_string()));
//std::forward<string>(message)));
}
}
}
// FIXME efficiency!!!
void TcpConnection::send(Buffer* buf)
{
if (state_ == kConnected)
{
if (loop_->isInLoopThread())
{
sendInLoop(buf->peek(), buf->readableBytes());
buf->retrieveAll();
}
else
{
void (TcpConnection::*fp)(const StringPiece& message) = &TcpConnection::sendInLoop;
loop_->runInLoop(
std::bind(fp,
this, // FIXME
buf->retrieveAllAsString()));
//std::forward<string>(message)));
}
}
}
void TcpConnection::sendInLoop(const StringPiece& message)
{
sendInLoop(message.data(), message.size());
}
void TcpConnection::sendInLoop(const void* data, size_t len)
{
loop_->assertInLoopThread();
ssize_t nwrote = 0;
size_t remaining = len;
bool faultError = false;
if (state_ == kDisconnected)
{
LOG_WARN << "disconnected, give up writing";
return;
}
// if no thing in output queue, try writing directly
//通道没有关注可写事件，并且发送缓冲区没有数据，直接write
if (!channel_->isWriting() && outputBuffer_.readableBytes() == 0)
{
nwrote = sockets::write(channel_->fd(), data, len);
if (nwrote >= 0)
{
remaining = len - nwrote;
if (remaining == 0 && writeCompleteCallback_)
{
//写完了，回调writeCompleteCallback
loop_->queueInLoop(std::bind(writeCompleteCallback_, shared_from_this()));
}
}
else // nwrote < 0
{
nwrote = 0;
if (errno != EWOULDBLOCK)
{
LOG_SYSERR << "TcpConnection::sendInLoop";
if (errno == EPIPE || errno == ECONNRESET) // FIXME: any others?
{
faultError = true;
}
}
}
}
assert(remaining <= len);
//没有错误，并且还有未写完的数据，（说明内核缓冲区已满要将未写完的数据添加到output buffer中）
if (!faultError && remaining > 0)
{
size_t oldLen = outputBuffer_.readableBytes();
if (oldLen + remaining >= highWaterMark_
&& oldLen < highWaterMark_
&& highWaterMarkCallback_)
{
loop_->queueInLoop(std::bind(highWaterMarkCallback_, shared_from_this(), oldLen + remaining));
}
outputBuffer_.append(static_cast<const char*>(data)+nwrote, remaining);
if (!channel_->isWriting())
{
channel_->enableWriting(); //关注POLLOUT事件
}
}
}
读上述代码可知，数据的发送都是通过sendInLoop函数在I/O线程中进行。发送数据的逻辑是：
- 当channel_没有关注POLLOUT事件并且输出缓冲区没有要发送的数据时开始尝试一次性发送完毕。
- 当一次没有发送完毕还剩余数据时，就将剩余数据加入Tcpconnection的输出缓冲区outputBuffer_中，并且注册POLLOUT（这里注意因为muduo采用水平触发LT模式，因此只有在缓冲区有数据要发送时才注册POLLOUT事件，发送完毕应该立即取消注册，不然会一直触发可写事件）
- 由于注册了PLOLLOUT事件，且采用LT触发，因此事件循环时Tcpconnection的channel会触发写事件，回调WriteCallback_，由于在Tcpconnection对象建立时channel的WriteCallback_就被绑定在TcpConnection::handleWrite上（见Tcpconnection类的构造函数），因此调用TcpConnection::handleWrite函数，如下：
void TcpConnection::handleWrite()
{
loop_->assertInLoopThread();
if (channel_->isWriting()) //如果关注了可写事件，则直接往套接字文件描述符中写数据
{
ssize_t n = sockets::write(channel_->fd(),
outputBuffer_.peek(),
outputBuffer_.readableBytes());
if (n > 0)
{
outputBuffer_.retrieve(n);
if (outputBuffer_.readableBytes() == 0) //说明发送缓冲区已经清空
{
channel_->disableWriting(); //停止关注POLLOUT事件，以免出现busy loop
if (writeCompleteCallback_) //回调writeCompleteCallback_
{
loop_->queueInLoop(std::bind(writeCompleteCallback_, shared_from_this()));
}
if (state_ == kDisconnecting) //发送缓冲区已经清空，并且连接状态为kDisconnecting，要关闭连接
{
shutdownInLoop(); //关闭连接
}
}
}
else
{
LOG_SYSERR << "TcpConnection::handleWrite";
// if (state_ == kDisconnecting)
// {
// shutdownInLoop();
// }
}
}
else
{
LOG_TRACE << "Connection fd = " << channel_->fd()
<< " is down, no more writing";
}
}
- TcpConnection::handleWrite函数会把输入缓冲区中的数据全部发送给对方，当发送完毕时，立即停止关注POLLOUT事件，以免出现busy loop，如果设置了用户回调函数writeCompleteCallback_就将回调函数loop的 pendingFunctors_中，在事件循环中调用writeCompleteCallback_函数。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
