学习Libuv写TCP服务器程序，首先从示例代码看起。示例代码给出了基本的使用流程，为了更清晰的看懂示例代码，我将我的总结注释在代码上，供大家学习参考。

        Libuv的基本思想是，处处回调，所以你能看到，这些函数从下到上是一步步的函数回调形成的关系链。依次处理完这些函数，一个请求的接受到读取数据，再到回复数据给客户端，最后清理资源，完毕。

        下面是完整的代码，含详细注释：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <uv.h>

#define DEFAULT_PORT 7000
#define DEFAULT_BACKLOG 128

uv_loop_t *loop;
struct sockaddr_in addr;

typedef struct 
{
 uv_write_t req;
 uv_buf_t buf;
} write_req_t;

void free_write_req(uv_write_t *req) 
{
    //释放的时候注意先将对象内部使用的缓存释放，然后再释放对象本身
 write_req_t *wr = (write_req_t*) req;
 free(wr->buf.base);
 free(wr);
}

void echo_write(uv_write_t *req, int status) 
{
 if (status) {
        //状态值status不为0表示发送数据失败。
 fprintf(stderr, "Write error %s\n", uv_strerror(status));
 }
    //不管发送数据成功与否，都要执行下面的函数释放资源，以免内存泄露
 free_write_req(req);
}

void echo_read(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) 
{
    //分配好的缓存在这里使用，使用完后最后回释放
 if (nread > 0) 
    {
        //实际读取到了内容
        //为回复客户端数据创建一个写数据对象write_req_t，写数据对象内存将会在写完后的回调函数中释放
        //因为发送完的数据在发送完毕后无论成功与否，都会释放内存。如果一定要确保发送出去，那么请自己存储好发送的数据，直到echo_write执行完再释放。
 write_req_t *req = (write_req_t*) malloc(sizeof(write_req_t));
        //用缓存中的起始地址和大小初始化写数据对象write_req_t
 req->buf = uv_buf_init(buf->base, nread);
        //写数据，并将写数据对象write_req_t和客户端、缓存、回调函数关联，第四个参数表示创建一个uv_buf_t缓存，不是1个字节
        uv_write((uv_write_t*) req, client, &req->buf, 1, echo_write);
        //连续回复多条数据，请使用多个写数据对象write_req_t
        write_req_t *req2 = (write_req_t*) malloc(sizeof(write_req_t));
        req2->buf = uv_buf_init(buf->base, nread);
        uv_write((uv_write_t*) req2, client, &req2->buf, 1, echo_write);
 }
    else if(nread == 0)
    {
        //读取成功，但是没有读取到任何数据而已
    }
 else
    {
        //读取到的数据大小小于零，表示读取出错
 if (nread != UV_EOF)
            fprintf(stderr, "Read error %s\n", uv_err_name(nread));
 uv_close((uv_handle_t*) client, NULL);
 }
 //确保这句代码一定会在最后面执行，不要在中间突然退出函数，否则就内存泄露了
 free(buf->base);
}
void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) 
{
    //分配接收缓存内存和设置建议大小，小于等于实际大小
 buf->base = (char*) malloc(suggested_size);
 buf->len = suggested_size;
}

void on_new_connection(uv_stream_t *server, int status) {
 if (status < 0) 
    {
        //新建连接出错
 fprintf(stderr, "New connection error %s\n", uv_strerror(status));
 // error!
 return;
 }
 //分配内存
 uv_tcp_t *client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
    //将全局的主循环和处理连接的对象关联起来
 uv_tcp_init(loop, client);
    //接收服务端对象
 if (uv_accept(server, (uv_stream_t*) client) == 0) 
    {
        //开始读取客户端发送的数据，并设置好接收缓存分配的函数alloc_buffer和读取完毕后的回调函数echo_read
 uv_read_start((uv_stream_t*) client, alloc_buffer, echo_read);
 }
 else 
    {
        //读取失败，释放处理对象
 uv_close((uv_handle_t*) client, NULL);
 }
}

int main() 
{
    //默认全局的主循环
 loop = uv_default_loop();
    //TCP服务端对象
 uv_tcp_t server;
    //初始化，将TCP服务端对象和主循环绑定在一起
 uv_tcp_init(loop, &server);
    //创建IP地址和端口，服务器使用0.0.0.0代表任意地址，公网服务器使用，客户端可以通过公网IP连接。如果是局域网，则填写局域网IP。
 uv_ip4_addr("0.0.0.0", DEFAULT_PORT, &addr);
    //将服务端对象和地址绑定，供后续监听端口使用。
 uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);
    //进行端口监听，同时关联监听后进来的连接的回调函数
 int r = uv_listen((uv_stream_t*) &server, DEFAULT_BACKLOG, on_new_connection);
 if (r) 
    {
 fprintf(stderr, "Listen error %s\n", uv_strerror(r));
 return 1;
 }
    //设置好以上的信息之后，只是做好参数配置，要真正运行需要让主循环执行
 return uv_run(loop, UV_RUN_DEFAULT);
}