自学教程：C++ uv_unref函数代码示例

void V8SynchronizationContext::Unref(uv_edge_async_t* uv_edge_async){#if UV_VERSION_MAJOR==0 && UV_VERSION_MINOR<8    uv_unref(uv_default_loop());#else    uv_unref((uv_handle_t*)&uv_edge_async->uv_async);#endif  }

void CefLoop::StopLoop(uv_handle_t* handle) {  CefShutdown();#if NODE_VERSION_AT_LEAST(0, 7, 9)  uv_unref((uv_handle_t *)&g_async);#else  uv_unref(uv_default_loop());#endif}

void CefLoop::Pause() {  if( !CefLoop::initialized_ || !CefLoop::running_ ) return;  uv_timer_stop(&timer);#if NODE_VERSION_AT_LEAST(0, 7, 9)  uv_unref((uv_handle_t *)&g_async);#else  uv_unref(uv_default_loop());#endif    CefLoop::running_ = false;}

static int couv_unref(lua_State *L) {  uv_handle_t *handle;  handle = couvL_checkudataclass(L, 1, COUV_HANDLE_MTBL_NAME);  uv_unref(handle);  return 0;}

/** * CB for new connection requests. */void on_connection(uv_stream_t *server, int status){  if (status < 0) {    fprintf(stderr, "New connection error: %s/n",             uv_strerror(uv_last_error(server->loop)));    return;  }    client_t *clnt = (client_t *)malloc(sizeof(client_t));  client_init(clnt);  uv_tcp_init(server->loop, &clnt->source);  if (uv_accept(server, (uv_stream_t *)&clnt->source) != 0) {    fprintf(stderr, "Accept failed: %s/n",             uv_strerror(uv_last_error(server->loop)));    uv_close((uv_handle_t *)&clnt->source, NULL);    free(clnt);    return;  }  // succesfull accept here  clnt->source.data = (void *)clnt;  uv_read_start((uv_stream_t *)&clnt->source, alloc_buffer, on_read);  // unref server to force program termination when client disconnects  uv_unref((uv_handle_t *)server);}

void ZipFile::Work_AfterReadFile(uv_work_t* req) {    HandleScope scope;    closure_t *closure = static_cast<closure_t *>(req->data);    TryCatch try_catch;    if (closure->error) {        Local<Value> argv[1] = { Exception::Error(String::New(closure->error_name.c_str())) };        closure->cb->Call(Context::GetCurrent()->Global(), 1, argv);    } else {        node::Buffer *retbuf = Buffer::New(reinterpret_cast<char *>(&closure->data[0]), closure->data.size());        Local<Value> argv[2] = { Local<Value>::New(Null()), Local<Value>::New(retbuf->handle_) };        closure->cb->Call(Context::GetCurrent()->Global(), 2, argv);    }    if (try_catch.HasCaught()) {        FatalException(try_catch);    }    closure->zf->Unref();    uv_unref(uv_default_loop());    closure->cb.Dispose();    delete closure;}

ssize_t HTTPConnectionReadRequest(HTTPConnectionRef const conn, HTTPMethod *const method, str_t *const out, size_t const max) {	if(!conn) return UV_EINVAL;	if(!max) return UV_EINVAL;	uv_buf_t buf[1];	int rc;	HTTPEvent type;	size_t len = 0;	for(;;) {		// Use unref because we shouldn't block the server		// on a request that may never arrive.		uv_unref((uv_handle_t *)conn->stream);		rc = HTTPConnectionPeek(conn, &type, buf);		uv_ref((uv_handle_t *)conn->stream);		if(rc < 0) return rc;		if(HTTPHeaderField == type || HTTPHeadersComplete == type) break;		HTTPConnectionPop(conn, buf->len);		if(HTTPMessageBegin == type) continue;		if(HTTPURL != type) {			assertf(0, "Unexpected HTTP event %d", type);			return UV_UNKNOWN;		}		if(len+buf->len+1 > max) return UV_EMSGSIZE;		memcpy(out+len, buf->base, buf->len);		len += buf->len;		out[len] = '/0';	}	*method = conn->parser->method;	return (ssize_t)len;}

/* * Class:     com_oracle_libuv_handles_Handle * Method:    _unref * Signature: (J)V */JNIEXPORT void JNICALL Java_com_oracle_libuv_handles_Handle__1unref  (JNIEnv *env, jobject that, jlong ptr) {  assert(ptr);  uv_handle_t* handle = reinterpret_cast<uv_handle_t*>(ptr);  uv_unref(handle);}

void uv_pipe_endgame(uv_pipe_t* handle) {  uv_err_t err;  int status;  if (handle->flags & UV_HANDLE_SHUTTING &&      !(handle->flags & UV_HANDLE_SHUT) &&      handle->write_reqs_pending == 0) {    close_pipe(handle, &status, &err);    if (handle->shutdown_req->cb) {      if (status == -1) {        LOOP->last_error = err;      }      handle->shutdown_req->cb(handle->shutdown_req, status);    }    handle->reqs_pending--;  }  if (handle->flags & UV_HANDLE_CLOSING &&      handle->reqs_pending == 0) {    assert(!(handle->flags & UV_HANDLE_CLOSED));    handle->flags |= UV_HANDLE_CLOSED;    if (handle->close_cb) {      handle->close_cb((uv_handle_t*)handle);    }    uv_unref();  }}

static void tcp_recv(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf){	uv_loop_t *loop = handle->loop;	struct worker_ctx *worker = loop->data;	/* Check for originator connection close. */	if (nread <= 0) {		if (handle->data) {			worker_exec(worker, (uv_handle_t *)handle, NULL, NULL);		}		if (!uv_is_closing((uv_handle_t *)handle)) {			uv_close((uv_handle_t *)handle, handle_free);		}		return;	}		int ret = worker_process_tcp(worker, (uv_handle_t *)handle, (const uint8_t *)buf->base, nread);	if (ret == 0) {		/* Push - pull, stop reading from this handle until		 * the task is finished. Since the handle has no track of the		 * pending tasks, it might be freed before the task finishes		 * leading various errors. */		uv_unref((uv_handle_t *)handle);		io_stop_read((uv_handle_t *)handle);	}	mp_flush(worker->pkt_pool.ctx);}

 ALWAYS_INLINE void releaseHandle(uv_idle_ext_t *handle) {     if(handle->start){         uv_idle_stop((uv_idle_t *) handle);     }     uv_unref((uv_handle_t *) handle);     delete handle; }

static int uv_getaddrinfo_done(eio_req* req) {  uv_getaddrinfo_t* handle = req->data;  struct addrinfo *res = handle->res;  handle->res = NULL;  uv_unref(handle->loop);  free(handle->hints);  free(handle->service);  free(handle->hostname);  if (handle->retcode == 0) {    /* OK */#if EAI_NODATA /* FreeBSD deprecated EAI_NODATA */  } else if (handle->retcode == EAI_NONAME || handle->retcode == EAI_NODATA) {#else  } else if (handle->retcode == EAI_NONAME) {#endif    uv__set_sys_error(handle->loop, ENOENT); /* FIXME compatibility hack */  } else {    handle->loop->last_err.code = UV_EADDRINFO;    handle->loop->last_err.sys_errno_ = handle->retcode;  }  handle->cb(handle, handle->retcode, res);  return 0;}

EventLoop::EventLoop() : deletingObjects(false) {	uv_loop_init(&loop);	deleteObjectsHandle.data = this;	uv_prepare_init(&loop, &deleteObjectsHandle);	uv_prepare_start(&deleteObjectsHandle, &staticDeleteObjects);	uv_unref((uv_handle_t*) &deleteObjectsHandle);}

void uv_fs_req_cleanup(uv_fs_t* req) {  uv_loop_t* loop = req->loop;  if (req->flags & UV_FS_CLEANEDUP) {    return;  }  if (req->flags & UV_FS_FREE_ARG0 && req->arg0) {    free(req->arg0);    req->arg0 = NULL;  }  if (req->flags & UV_FS_FREE_ARG1 && req->arg1) {    free(req->arg1);    req->arg1 = NULL;  }  if (req->flags & UV_FS_FREE_PTR && req->ptr) {    free(req->ptr);  }  req->ptr = NULL;  if (req->path) {    free(req->path);    req->path = NULL;  }  if (req->flags & UV_FS_ASYNC_QUEUED) {    uv_unref(loop);  }  req->flags |= UV_FS_CLEANEDUP;}

void NodeMap::renderFinished() {    Nan::HandleScope scope;    // We're done with this render call, so we're unrefing so that the loop could close.    uv_unref(reinterpret_cast<uv_handle_t *>(async));    // There is no render pending anymore, we the GC could now delete this object if it went out    // of scope.    Unref();    // Move the callback and image out of the way so that the callback can start a new render call.    auto cb = std::move(callback);    auto img = std::move(image);    assert(cb);    // These have to be empty to be prepared for the next render call.    assert(!callback);    assert(!image.data);    if (error) {        std::string errorMessage;        try {            std::rethrow_exception(error);        } catch (const std::exception& ex) {            errorMessage = ex.what();        }        v8::Local<v8::Value> argv[] = {            Nan::Error(errorMessage.c_str())        };        // This must be empty to be prepared for the next render call.        error = nullptr;        assert(!error);        cb->Call(1, argv);    } else if (img.data) {        v8::Local<v8::Object> pixels = Nan::NewBuffer(            reinterpret_cast<char *>(img.data.get()), img.size(),            // Retain the data until the buffer is deleted.            [](char *, void * hint) {                delete [] reinterpret_cast<uint8_t*>(hint);            },            img.data.get()        ).ToLocalChecked();        img.data.release();        v8::Local<v8::Value> argv[] = {            Nan::Null(),            pixels        };        cb->Call(2, argv);    } else {        v8::Local<v8::Value> argv[] = {            Nan::Error("Didn't get an image")        };        cb->Call(1, argv);    }}

grpc_endpoint *grpc_tcp_create(uv_tcp_t *handle,                               grpc_resource_quota *resource_quota,                               char *peer_string) {  grpc_tcp *tcp = (grpc_tcp *)gpr_malloc(sizeof(grpc_tcp));  if (grpc_tcp_trace) {    gpr_log(GPR_DEBUG, "Creating TCP endpoint %p", tcp);  }  /* Disable Nagle's Algorithm */  uv_tcp_nodelay(handle, 1);  memset(tcp, 0, sizeof(grpc_tcp));  tcp->base.vtable = &vtable;  tcp->handle = handle;  handle->data = tcp;  gpr_ref_init(&tcp->refcount, 1);  tcp->peer_string = gpr_strdup(peer_string);  tcp->shutting_down = false;  tcp->resource_user = grpc_resource_user_create(resource_quota, peer_string);  /* Tell network status tracking code about the new endpoint */  grpc_network_status_register_endpoint(&tcp->base);#ifndef GRPC_UV_TCP_HOLD_LOOP  uv_unref((uv_handle_t *)handle);#endif  return &tcp->base;}

void http_request_cache_configure_listener(uv_loop_t* loop, uv_async_t* handle){    uv_timer_t* cache_invalidation_timer = malloc(sizeof(uv_timer_t));    uv_timer_init(loop, cache_invalidation_timer);    uv_timer_start(cache_invalidation_timer, http_request_cache_timer, 500, 500);    uv_unref((uv_handle_t*) cache_invalidation_timer);}

void connection_consumer_start(void *arg){    int rc;    struct server_ctx *ctx;    uv_loop_t* loop;        ctx = arg;    loop = uv_loop_new();    listener_event_loops[ctx->index] = *loop;        http_request_cache_configure_listener(loop, &listener_async_handles[ctx->index]);    uv_barrier_wait(listeners_created_barrier);        rc = uv_async_init(loop, &ctx->async_handle, connection_consumer_close);    uv_unref((uv_handle_t*) &ctx->async_handle);        /* Wait until the main thread is ready. */    uv_sem_wait(&ctx->semaphore);    get_listen_handle(loop, (uv_stream_t*) &ctx->server_handle);    uv_sem_post(&ctx->semaphore);        rc = uv_listen((uv_stream_t*)&ctx->server_handle, 128, connection_consumer_new_connection);    rc = uv_run(loop, UV_RUN_DEFAULT);        uv_loop_delete(loop);}

void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,    uv_connect_t* req) {  assert(handle->type == UV_TCP);  if (req->cb) {    if (REQ_SUCCESS(req)) {      if (setsockopt(handle->socket,                      SOL_SOCKET,                      SO_UPDATE_CONNECT_CONTEXT,                      NULL,                      0) == 0) {        uv_connection_init((uv_stream_t*)handle);        loop->active_tcp_streams++;        ((uv_connect_cb)req->cb)(req, 0);      } else {        uv__set_sys_error(loop, WSAGetLastError());        ((uv_connect_cb)req->cb)(req, -1);      }    } else {      uv__set_sys_error(loop, GET_REQ_SOCK_ERROR(req));      ((uv_connect_cb)req->cb)(req, -1);    }  }  DECREASE_PENDING_REQ_COUNT(handle);  uv_unref(loop);}

void uv_fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle) {  if (handle->flags & UV_HANDLE_CLOSING &&      !handle->req_pending) {    assert(!(handle->flags & UV_HANDLE_CLOSED));    handle->flags |= UV_HANDLE_CLOSED;    if (handle->buffer) {      _aligned_free(handle->buffer);      handle->buffer = NULL;    }    if (handle->filew) {      free(handle->filew);      handle->filew = NULL;    }    if (handle->short_filew) {      free(handle->short_filew);      handle->short_filew = NULL;    }    if (handle->filename) {      free(handle->filename);      handle->filename = NULL;    }    if (handle->close_cb) {      handle->close_cb((uv_handle_t*)handle);    }    uv_unref(loop);  }}

void uv_process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle,    uv_write_t* req) {  assert(handle->type == UV_TCP);  assert(handle->write_queue_size >= req->queued_bytes);  handle->write_queue_size -= req->queued_bytes;  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {    if (req->wait_handle != INVALID_HANDLE_VALUE) {      UnregisterWait(req->wait_handle);    }    if (req->event_handle) {      CloseHandle(req->event_handle);    }  }  if (req->cb) {    uv__set_sys_error(loop, GET_REQ_SOCK_ERROR(req));    ((uv_write_cb)req->cb)(req, loop->last_err.code == UV_OK ? 0 : -1);  }  handle->write_reqs_pending--;  if (handle->flags & UV_HANDLE_SHUTTING &&      handle->write_reqs_pending == 0) {    uv_want_endgame(loop, (uv_handle_t*)handle);  }  DECREASE_PENDING_REQ_COUNT(handle);  uv_unref(loop);}

MVMint64 MVM_io_syncstream_write_str(MVMThreadContext *tc, MVMOSHandle *h, MVMString *str, MVMint64 newline) {    MVMIOSyncStreamData *data = (MVMIOSyncStreamData *)h->body.data;    MVMuint8 *output;    MVMint64 output_size;    uv_write_t *req;    uv_buf_t write_buf;    int r;    output = MVM_string_encode(tc, str, 0, -1, &output_size, data->encoding);    if (newline) {        output = (MVMuint8 *)realloc(output, ++output_size);        output[output_size - 1] = '/n';    }    req = malloc(sizeof(uv_write_t));    write_buf = uv_buf_init(output, output_size);    uv_ref((uv_handle_t *)data->handle);    if ((r = uv_write(req, data->handle, &write_buf, 1, write_cb)) < 0) {        uv_unref((uv_handle_t *)data->handle);        free(req);        free(output);        MVM_exception_throw_adhoc(tc, "Failed to write string to stream: %s", uv_strerror(r));    }    else {        uv_run(tc->loop, UV_RUN_DEFAULT);        free(output);    }    data->total_bytes_written += output_size;    return output_size;}

/* TODO: share this with windows? */int uv_ares_init_options(uv_loop_t* loop, ares_channel *channelptr,    struct ares_options *options, int optmask) {  int rc;  /* only allow single init at a time */  if (loop->channel != NULL) {    uv__set_artificial_error(loop, UV_EALREADY);    return -1;  }  /* set our callback as an option */  options->sock_state_cb = uv__ares_sockstate_cb;  options->sock_state_cb_data = loop;  optmask |= ARES_OPT_SOCK_STATE_CB;  /* We do the call to ares_init_option for caller. */  rc = ares_init_options(channelptr, options, optmask);  /* if success, save channel */  if (rc == ARES_SUCCESS) {    loop->channel = *channelptr;  }   /*   * Initialize the timeout timer. The timer won't be started until the   * first socket is opened.   */  uv_timer_init(loop, &loop->timer);  uv_unref(loop);  loop->timer.data = loop;  return rc;}

static void socket_bind(MVMThreadContext *tc, MVMOSHandle *h, MVMString *host, MVMint64 port, MVMint32 backlog) {    MVMIOSyncSocketData *data = (MVMIOSyncSocketData *)h->body.data;    if (!data->ss.handle) {        struct sockaddr *dest    = MVM_io_resolve_host_name(tc, host, port);        uv_tcp_t        *socket  = MVM_malloc(sizeof(uv_tcp_t));        int r;        if ((r = uv_tcp_init(tc->loop, socket)) != 0 ||                (r = uv_tcp_bind(socket, dest, 0)) != 0) {            MVM_free(socket);            MVM_free(dest);            MVM_exception_throw_adhoc(tc, "Failed to bind: %s", uv_strerror(r));        }        MVM_free(dest);        /* Start listening, but unref the socket so it won't get in the way of         * other things we want to do on this event loop. */        socket->data = data;        if ((r = uv_listen((uv_stream_t *)socket, backlog, on_connection)) != 0) {            MVM_free(socket);            MVM_exception_throw_adhoc(tc, "Failed to listen: %s", uv_strerror(r));        }        uv_unref((uv_handle_t *)socket);        data->ss.handle = (uv_stream_t *)socket;    }    else {        MVM_exception_throw_adhoc(tc, "Socket is already bound or connected");    }}

static void on_connection(uv_stream_t *server, int status) {    /* Stash data for a later accept call (safe as we specify a queue of just     * one connection). Decrement reference count also. */    MVMIOSyncSocketData *data = (MVMIOSyncSocketData *)server->data;    data->accept_server = server;    data->accept_status = status;    uv_unref((uv_handle_t *)server);}

static int uv__after_work(eio_req *eio) {  uv_work_t* req = eio->data;  uv_unref(req->loop);  if (req->after_work_cb) {    req->after_work_cb(req);  }  return 0;}

static PyObject *Handle_func_unref(Handle *self){    RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);    RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);    uv_unref(self->uv_handle);    Py_RETURN_NONE;}

void TSockSys::UnrefLoop() { 	IAssert(LoopRef != NULL);	// unrefernce the timer	uv_unref((uv_handle_t*)LoopRef); 	// kill the timer	uv_close((uv_handle_t*)LoopRef, NULL);	LoopRef = NULL;}

static void on_connect(uv_connect_t* req, int status) {    uv_unref((uv_handle_t *)req->handle);    if (status < 0) {        MVMThreadContext *tc = ((MVMIOSyncSocketData *)req->data)->ss.cur_tc;        MVM_free(req);        MVM_exception_throw_adhoc(tc, "Failed to connect: %s", uv_strerror(status));    }}