|
TCP客户端连接步骤： ① .连接方法 Uv_loop_t *loop = uv_default_loop();
uv_tcp_t *client = malloc…; uv_connect_t* connect_req = malloc…;
uv_tcp_init(loop, client)
uv_tcp_connect(connect_req, client, addr, connect_cb);
uv_run(loop);
getchar(); //服务端不需要这个，现在还不明白为什么
②.回调函数 static void connect_cb(uv_connect_t*req, int status) { int r; uv_buf_t buf = uv_buf_init("just test", 10);
这必须是动态分配内存，在uv_write函数内部会对这个指针赋值。 uv_write_t *reqw = (uv_write_t*)malloc(sizeof *reqw);
在write_cb中，释放分配的内存。 r = uv_write(reqw, (uv_stream_t*)(req->handle),&buf, 1, write_cb); }
static void write_cb(uv_write_t*req, int status) { } static void read_cb(uv_stream_t*tcp, ssize_t nread, uv_buf_t buf) { } uv_connect_tis a subclass of uv_req_t
2.TCP服务端连接步骤 ①.连接方法 loop = uv_default_loop();
structsockaddr_in addr = uv_ip4_addr("127.0.0.1",5432); int r;
server = (uv_handle_t*)&tcpServer; r = uv_tcp_init(loop, &tcpServer); if (r){ std::cout << "Socket creation error" <<std::endl; return; }
r = uv_tcp_bind(&tcpServer, addr); if (r){ std::cout << "Bind error" << std::endl; return; }
r =uv_listen((uv_stream_t*)&tcpServer, 10, on_connection); if (r){ std::cout << "Listen error" << std::endl; return; }
uv_run(loop);
②.回调函数 static voidon_connection(uv_stream_t* server, int status) { uv_stream_t* stream; int r; 用这种方式来初始化一个新连接 stream = (uv_stream_t*)malloc(sizeof(uv_tcp_t)); ASSERT(stream != NULL); r = uv_tcp_init(loop,(uv_tcp_t*)stream); stream->data = server; r = uv_accept(server, stream); }
*uv_stream_t is a subclass of uv_handle_t * * uv_stream is an abstract class. * * uv_stream_t is the parent class of uv_tcp_t,uv_pipe_t, uv_tty_t, and * soon uv_file_t.
在客户端的连接中 Uv_tcp_connect(connect_req…);connect_req是一个uv_connect_t*参数，相应的connect_cb的第一个参数为uv_connect_t*,(uv_connect_t是uv_req_t的子类)
服务端的连接中 uv_listen((uv_stream_t*)&tcpServer,10, on_connection);相应的on_connect的第一个参数为uv_stream_t*
看来node.js的思想和ACE非常像，把请求对象和连接对象分别封装成不同概念的东西。
3.tcp –open 创建套接字然后使用uv_tcp_open，再uv_tcp_connect时，函数内部不会再创建套接字，仅此而已。
4.tcp_read_stop Uv_read_stop((uv_stream_t*)&tcp_handle); Uv_close((uv_handle_t*)tcp_handle);
UDP客户端： uv_udp_send_t req; r = uv_udp_init(uv_default_loop(),&client); ASSERT(r == 0);
buf = uv_buf_init("PING", 4); r = uv_udp_send(&req, &client,&buf, 1, addr, cl_send_cb);
voidcl_send_cb(uv_udp_send_t* req, intstatus) {} UDP服务端： r = uv_udp_init(uv_default_loop(),&server); ASSERT(r == 0);
r = uv_udp_bind(&server, addr, 0); ASSERT(r == 0);
r = uv_udp_recv_start(&server,alloc_cb, sv_recv_cb); ASSERT(r == 0);
static void sv_recv_cb(uv_udp_t* handle, ssize_tnread, uv_buf_tbuf, struct sockaddr* addr, unsigned flags) {}
定时器： int64_t start_time = uv_now(uv_default_loop());
void never_cb(uv_timer_t* handle, int status) { std::cout << "never_cb should never be called"<< std::endl; }
static voidonce_close_cb(uv_handle_t*handle) {} static voidonce_cb(uv_timer_t* handle, int status) {
uv_close((uv_handle_t*)handle, once_close_cb);
uv_update_time(uv_default_loop()); }
r = uv_timer_init(uv_default_loop(), &never); ASSERT(r == 0); r = uv_timer_start(&never, never_cb, 100, 100); ASSERT(r == 0); r = uv_timer_stop(&never); ASSERT(r == 0); uv_unref((uv_handle_t*)&never);
uv_run(uv_default_loop());
同步对象： uv_cond_init(&signal_cond) uv_cond_destroy(&signal_cond);
If libuv has been compiled with debuggingenabled, uv_mutex_destroy(), uv_mutex_lock() and uv_mutex_unlock() will abort() on error.Similarly uv_mutex_trylock() will abort if the error is anything otherthan EAGAIN.
Note: Libuv 里面有read/write锁uv_rwlock_t numlock; Warning mutexesand rwlocks DO NOT work inside a signal handler, whereas uv_async_send does.
线程间通信用uv_async_t
线程对象： uv_thread_t tid; int r;
r = uv_thread_create(&tid,thread_entry, (void*)42); ASSERT(r == 0);
r = uv_thread_join(&tid);
线程池： r = uv_queue_work(uv_default_loop(),&work_req, NULL, after_work_cb); //倒数第二个参数为NULL，返回-1，after_work_cb也不会被调用 ASSERT(r == -1);
libuv work queue? uv_queue_work() is a convenience function that allows an application torun a task in a separate thread, and have a callback that is triggered when thetask is done. A seemingly simple function, what makes uv_queue_work() tempting is that it allows potentiallyany third-party libraries to be used with the event-loop paradigm. When you useevent loops, it is imperativeto make sure that no function which runs periodically in the loop thread blockswhen performing I/O or is a serious CPU hog, because this means the loop slows downand events are not being dealt with at full capacity. 意思是：IO线程里面不应该有阻塞操作，libuv的处理方式是让系统自己处理这些阻塞操作。就是IOCP嘛。 |
|
|
