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

static void saturate_threadpool(void) {  uv_work_t* req;  ASSERT(0 == uv_cond_init(&signal_cond));  ASSERT(0 == uv_mutex_init(&signal_mutex));  ASSERT(0 == uv_mutex_init(&wait_mutex));  uv_mutex_lock(&signal_mutex);  uv_mutex_lock(&wait_mutex);  for (num_threads = 0; /* empty */; num_threads++) {    req = malloc(sizeof(*req));    ASSERT(req != NULL);    ASSERT(0 == uv_queue_work(uv_default_loop(), req, work_cb, done_cb));    /* Expect to get signalled within 350 ms, otherwise assume that     * the thread pool is saturated. As with any timing dependent test,     * this is obviously not ideal.     */    if (uv_cond_timedwait(&signal_cond, &signal_mutex, (uint64_t)(350 * 1e6))) {      ASSERT(0 == uv_cancel((uv_req_t*) req));      break;    }  }}

Session::Session()    : state_(SESSION_STATE_CLOSED)    , current_host_mark_(true)    , pending_resolve_count_(0)    , pending_pool_count_(0)    , pending_workers_count_(0)    , current_io_worker_(0) {  uv_mutex_init(&state_mutex_);  uv_mutex_init(&hosts_mutex_);}

Session::Session()    : state_(SESSION_STATE_CLOSED)    , connect_error_code_(CASS_OK)    , current_host_mark_(true)    , pending_pool_count_(0)    , pending_workers_count_(0)    , current_io_worker_(0) {  uv_mutex_init(&state_mutex_);  uv_mutex_init(&hosts_mutex_);  uv_mutex_init(&keyspace_mutex_);}

IOWorker::IOWorker(Session* session)    : session_(session)    , config_(session->config())    , metrics_(session->metrics())    , protocol_version_(-1)    , is_closing_(false)    , pending_request_count_(0)    , request_queue_(config_.queue_size_io()) {  prepare_.data = this;  uv_mutex_init(&keyspace_mutex_);  uv_mutex_init(&unavailable_addresses_mutex_);}

inline static int uv__rwlock_fallback_init(uv_rwlock_t* rwlock) {  if (uv_mutex_init(&rwlock->fallback_.read_mutex_)) return -1;  if (uv_mutex_init(&rwlock->fallback_.write_mutex_)) {    uv_mutex_destroy(&rwlock->fallback_.read_mutex_);    return -1;  }  rwlock->fallback_.num_readers_ = 0;  return 0;}

int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) {  struct _uv_barrier* b;  int rc;  if (barrier == NULL || count == 0)    return UV_EINVAL;  b = uv__malloc(sizeof(*b));  if (b == NULL)    return UV_ENOMEM;  b->in = 0;  b->out = 0;  b->threshold = count;  rc = uv_mutex_init(&b->mutex);  if (rc != 0)    goto error2;  rc = uv_cond_init(&b->cond);  if (rc != 0)    goto error;  barrier->b = b;  return 0;error:  uv_mutex_destroy(&b->mutex);error2:  uv__free(b);  return rc;}

/* Populates the object body with a mutex. */static void initialize_mutex(MVMThreadContext *tc, MVMReentrantMutexBody *rm) {    int init_stat;    rm->mutex = MVM_malloc(sizeof(uv_mutex_t));    if ((init_stat = uv_mutex_init(rm->mutex)) < 0)        MVM_exception_throw_adhoc(tc, "Failed to initialize mutex: %s",            uv_strerror(init_stat));}

void eventpool_init(enum eventpool_threads_t t) {	/*	 * Make sure we execute in the main thread	 */	const uv_thread_t pth_cur_id = uv_thread_self();	assert(uv_thread_equal(&pth_main_id, &pth_cur_id));	if(eventpoolinit == 1) {		return;	}	eventpoolinit = 1;	threads = t;	if((async_req = MALLOC(sizeof(uv_async_t))) == NULL) {		OUT_OF_MEMORY /*LCOV_EXCL_LINE*/	}	uv_async_init(uv_default_loop(), async_req, eventpool_execute);	if(lockinit == 0) {		lockinit = 1;		// pthread_mutexattr_init(&listeners_attr);		// pthread_mutexattr_settype(&listeners_attr, PTHREAD_MUTEX_RECURSIVE);		// pthread_mutex_init(&listeners_lock, &listeners_attr);		uv_mutex_init(&listeners_lock);	}}

static void init_once(void) {  unsigned int i;  const char* val;  nthreads = ARRAY_SIZE(default_threads);  val = getenv("UV_THREADPOOL_SIZE");  if (val != NULL) nthreads = atoi(val);  if (nthreads == 0) nthreads = 1;  if (nthreads > MAX_THREADPOOL_SIZE) nthreads = MAX_THREADPOOL_SIZE;  threads = default_threads;  if (nthreads > ARRAY_SIZE(default_threads)) {    threads = malloc(nthreads * sizeof(threads[0]));    if (threads == NULL) {      nthreads = ARRAY_SIZE(default_threads);      threads = default_threads;    }  }  if (uv_cond_init(&cond)) abort();  if (uv_mutex_init(&mutex)) abort();  QUEUE_INIT(&wq);  for (i = 0; i < nthreads; i++)    if (uv_thread_create(threads + i, worker, NULL)) abort();  initialized = 1;}

Adapter::Adapter(){    adapter = nullptr;    eventCallbackMaxCount = 0;    eventCallbackBatchEventCounter = 0;    eventCallbackBatchEventTotalCount = 0;    eventCallbackBatchNumber = 0;    eventCallback = nullptr;    eventIntervalTimer = nullptr;    asyncEvent = nullptr;    asyncLog = nullptr;    asyncStatus = nullptr;    adapterCloseMutex = new uv_mutex_t();    if (uv_mutex_init(adapterCloseMutex) != 0)    {        std::cerr << "Not able to create adapterCloseMutex! Terminating." << std::endl;        std::terminate();    }    adapters.push_back(this);}

  LatencyAwarePolicyTest()    : ccm_(new CCM::Bridge("config.txt"))    , cluster_(cass_cluster_new())    , thread_() {    uv_mutex_init(&lock_);    uv_cond_init(&condition_);    // Create the cluster    if (ccm_->create_cluster(3)) {      ccm_->start_cluster();    }    // Initialize the cluster for latency aware    cass_cluster_set_reconnect_wait_time(cluster_.get(), 1);    cass_cluster_set_connect_timeout(cluster_.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);    cass_cluster_set_request_timeout(cluster_.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);    test_utils::initialize_contact_points(cluster_.get(), ccm_->get_ip_prefix(), 3, 0);    cass_cluster_set_latency_aware_routing(cluster_.get(), cass_true);    cass_cluster_set_latency_aware_routing_settings(cluster_.get(), 1e6, 1, 1, 1, 1);    // Handle deprecated and removed protocol versions [CASSANDRA-10146]    // https://issues.apache.org/jira/browse/CASSANDRA-10146    int protocol_version = 1;    if (test_utils::get_version() >= "3.0.0") {      protocol_version = 3;    }    cass_cluster_set_protocol_version(cluster_.get(), protocol_version); // Protocol for this test doesn't matter so simply support all C* versions    // Connect to the cluster    session_ = test_utils::create_session(cluster_.get());  }

int uv__platform_loop_init(uv_loop_t* loop, int default_loop) {  CFRunLoopSourceContext ctx;  int r;  if (uv__kqueue_init(loop))    return -1;  loop->cf_loop = NULL;  if ((r = uv_mutex_init(&loop->cf_mutex)))    return r;  if ((r = uv_sem_init(&loop->cf_sem, 0)))    return r;  QUEUE_INIT(&loop->cf_signals);  memset(&ctx, 0, sizeof(ctx));  ctx.info = loop;  ctx.perform = uv__cf_loop_cb;  loop->cf_cb = CFRunLoopSourceCreate(NULL, 0, &ctx);  if ((r = uv_thread_create(&loop->cf_thread, uv__cf_loop_runner, loop)))    return r;  /* Synchronize threads */  uv_sem_wait(&loop->cf_sem);  assert(ACCESS_ONCE(CFRunLoopRef, loop->cf_loop) != NULL);  return 0;}

int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) {  int err;  barrier->n = count;  barrier->count = 0;  err = uv_mutex_init(&barrier->mutex);  if (err)    return -err;  err = uv_sem_init(&barrier->turnstile1, 0);  if (err)    goto error2;  err = uv_sem_init(&barrier->turnstile2, 1);  if (err)    goto error;  return 0;error:  uv_sem_destroy(&barrier->turnstile1);error2:  uv_mutex_destroy(&barrier->mutex);  return -err;}

voidtor_init (void){	if (initialized) {		return;	}	ERR_load_crypto_strings();	OpenSSL_add_all_algorithms();	// enable proper threading	locks.length = CRYPTO_num_locks();	locks.item   = malloc(locks.length * sizeof(uv_mutex_t));	for (size_t i = 0; i < locks.length; i++) {		uv_mutex_init(&locks.item[i]);	}	CRYPTO_set_locking_callback(_locking_callback);	CRYPTO_set_id_callback(uv_thread_self);	CRYPTO_set_dynlock_create_callback(_dynlock_create_callback);	CRYPTO_set_dynlock_lock_callback(_dynlock_lock_callback);	CRYPTO_set_dynlock_destroy_callback(_dynlock_destroy_callback);	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();	initialized = true;}

JNIAPI Java_com_tangide_canvas_CanvasJNI_surfaceCreated(JNIEnv * env, jobject obj) {	int argc = 2;	struct stat st = {0};	lastRenderTime = getTime();	startupTime =  lastRenderTime;	const char* sysRoot = "/mnt/sdcard-ext/cantk-rt-v8";	if(!stat(sysRoot, &st) == 0) {		sysRoot = "/mnt/sdcard/cantk-rt-v8";	}	string str = "--sys-root=" + string(sysRoot);	char* argv[3] = {"android", (char*)str.c_str(), NULL};	Config::init(argc, argv);	V8Wrapper::init(argc, argv);	uv_mutex_init(&gLock);	const char* defaultAppIndex = "/mnt/sdcard-ext/cantk-rt-v8/scripts/cantk/index.html";	if(!stat(defaultAppIndex, &st) == 0) {		defaultAppIndex = "/mnt/sdcard/cantk-rt-v8/scripts/cantk/index.html";	}	V8Wrapper::loadApp(defaultAppIndex);}

Graph::Graph()   :thread(NULL)  ,is_running(false){  uv_mutex_init(&mutex);  uv_cond_init(&cv);}

inline static int uv__rwlock_fallback_init(uv_rwlock_t* rwlock) {  int err;  err = uv_mutex_init(&rwlock->fallback_.read_mutex_);  if (err)    return err;  err = uv_mutex_init(&rwlock->fallback_.write_mutex_);  if (err) {    uv_mutex_destroy(&rwlock->fallback_.read_mutex_);    return err;  }  rwlock->fallback_.num_readers_ = 0;  return 0;}

/** * create loop, mutex, and start the thread */UVEventLoop::UVEventLoop() {	runUV = false;	loop = uv_loop_new();	if (uv_mutex_init(&mutex) < 0) { // oops		;	}	StartUVRunner();}

/* Creates the allocator data structure with bins. */MVMFixedSizeAlloc * MVM_fixed_size_create(MVMThreadContext *tc) {    int init_stat;    MVMFixedSizeAlloc *al = MVM_malloc(sizeof(MVMFixedSizeAlloc));    al->size_classes = calloc(MVM_FSA_BINS, sizeof(MVMFixedSizeAllocSizeClass));    if ((init_stat = uv_mutex_init(&(al->complex_alloc_mutex))) < 0)        MVM_exception_throw_adhoc(tc, "Failed to initialize mutex: %s",            uv_strerror(init_stat));    return al;}

// initialize the threading infrastructurevoid jl_init_threadinginfra(void){    /* initialize the synchronization trees pool and the multiqueue */    multiq_init();    /* initialize the sleep mechanism */    uv_mutex_init(&sleep_lock);    uv_cond_init(&sleep_alarm);}

static mrb_valuemrb_uv_mutex_init(mrb_state *mrb, mrb_value self){  uv_mutex_t *m = (uv_mutex_t*)mrb_malloc(mrb, sizeof(uv_mutex_t));  mrb_uv_check_error(mrb, uv_mutex_init(m));  DATA_PTR(self) = m;  DATA_TYPE(self) = &mrb_uv_mutex_type;  return self;}

int uv_chan_init(uv_chan_t *chan) {    int r = uv_mutex_init(&chan->mutex);    if (r == -1)        return r;    QUEUE_INIT(&chan->q);    return uv_cond_init(&chan->cond);}

int status_init(Status* status, int initial_count) {  int rc;  rc = uv_mutex_init(&status->mutex);  if (rc != 0) return rc;  rc = uv_cond_init(&status->cond);  if (rc != 0) return rc;  status->count = initial_count;  return rc;}

void nub_loop_init(nub_loop_t* loop) {  uv_async_t* async_handle;  int er;  er = uv_loop_init(&loop->uvloop);  ASSERT(0 == er);  er = uv_prepare_init(&loop->uvloop, &loop->queue_processor_);  ASSERT(0 == er);  loop->queue_processor_.data = loop;  uv_unref((uv_handle_t*) &loop->queue_processor_);  er = uv_mutex_init(&loop->queue_processor_lock_);  ASSERT(0 == er);  fuq_init(&loop->blocking_queue_);  er = uv_sem_init(&loop->loop_lock_sem_, 0);  ASSERT(0 == er);  fuq_init(&loop->thread_dispose_queue_);  er = uv_mutex_init(&loop->thread_dispose_lock_);  ASSERT(0 == er);  fuq_init(&loop->work_queue_);  er = uv_mutex_init(&loop->work_lock_);  ASSERT(0 == er);  async_handle = (uv_async_t*) malloc(sizeof(*async_handle));  CHECK_NE(NULL, async_handle);  er = uv_async_init(&loop->uvloop, async_handle, nub__thread_dispose);  ASSERT(0 == er);  async_handle->data = loop;  loop->work_ping_ = async_handle;  uv_unref((uv_handle_t*) loop->work_ping_);  loop->ref_ = 0;  loop->disposed_ = 0;  er = uv_prepare_start(&loop->queue_processor_, nub__async_prepare_cb);  ASSERT(0 == er);}

void MVM_nfg_init(MVMThreadContext *tc) {    int init_stat;    tc->instance->nfg = calloc(1, sizeof(MVMNFGState));    if ((init_stat = uv_mutex_init(&(tc->instance->nfg->update_mutex))) < 0) {        fprintf(stderr, "MoarVM: Initialization of NFG update mutex failed/n    %s/n",            uv_strerror(init_stat));        exit(1);    }    cache_crlf(tc);}

void EIO_List(uv_work_t* req) {  // This code exists in javascript for unix platforms#ifdef __APPLE__  if(!lockInitialised)  {    uv_mutex_init(&list_mutex);    lockInitialised = TRUE;  }  ListBaton* data = static_cast<ListBaton*>(req->data);  stDeviceListItem* devices = GetSerialDevices();  if (*(devices->length) > 0)  {        stDeviceListItem* next = devices;        for (int i = 0, len = *(devices->length); i < len; i++) {        stSerialDevice device = (* next).value;        ListResultItem* resultItem = new ListResultItem();        resultItem->comName = device.port;        if (device.locationId != NULL) {          resultItem->locationId = device.locationId;        }        if (device.vendorId != NULL) {          resultItem->vendorId = device.vendorId;        }        if (device.productId != NULL) {          resultItem->productId = device.productId;        }        if (device.manufacturer != NULL) {          resultItem->manufacturer = device.manufacturer;        }        if (device.serialNumber != NULL) {          resultItem->serialNumber = device.serialNumber;        }        data->results.push_back(resultItem);        stDeviceListItem* current = next;        if (next->next != NULL)        {          next = next->next;        }        free(current);    }  }#endif}

static int uv__loop_init(uv_loop_t* loop, int default_loop) {  unsigned int i;  int err;  uv__signal_global_once_init();  memset(loop, 0, sizeof(*loop));  RB_INIT(&loop->timer_handles);  QUEUE_INIT(&loop->wq);  QUEUE_INIT(&loop->active_reqs);  QUEUE_INIT(&loop->idle_handles);  QUEUE_INIT(&loop->async_handles);  QUEUE_INIT(&loop->check_handles);  QUEUE_INIT(&loop->prepare_handles);  QUEUE_INIT(&loop->handle_queue);  loop->nfds = 0;  loop->watchers = NULL;  loop->nwatchers = 0;  QUEUE_INIT(&loop->pending_queue);  QUEUE_INIT(&loop->watcher_queue);  loop->closing_handles = NULL;  loop->time = uv__hrtime() / 1000000;  uv__async_init(&loop->async_watcher);  loop->signal_pipefd[0] = -1;  loop->signal_pipefd[1] = -1;  loop->backend_fd = -1;  loop->emfile_fd = -1;  loop->timer_counter = 0;  loop->stop_flag = 0;  err = uv__platform_loop_init(loop, default_loop);  if (err)    return err;  uv_signal_init(loop, &loop->child_watcher);  uv__handle_unref(&loop->child_watcher);  loop->child_watcher.flags |= UV__HANDLE_INTERNAL;  for (i = 0; i < ARRAY_SIZE(loop->process_handles); i++)    QUEUE_INIT(loop->process_handles + i);  if (uv_mutex_init(&loop->wq_mutex))    abort();  if (uv_async_init(loop, &loop->wq_async, uv__work_done))    abort();  uv__handle_unref(&loop->wq_async);  loop->wq_async.flags |= UV__HANDLE_INTERNAL;  return 0;}

int uv_loop_init(uv_loop_t* loop) {  int err;  uv__signal_global_once_init();  memset(loop, 0, sizeof(*loop));  heap_init((struct heap*) &loop->timer_heap);  QUEUE_INIT(&loop->wq);  QUEUE_INIT(&loop->active_reqs);  QUEUE_INIT(&loop->idle_handles);  QUEUE_INIT(&loop->async_handles);  QUEUE_INIT(&loop->check_handles);  QUEUE_INIT(&loop->prepare_handles);  QUEUE_INIT(&loop->handle_queue);  loop->nfds = 0;  loop->watchers = NULL;  loop->nwatchers = 0;  QUEUE_INIT(&loop->pending_queue);  QUEUE_INIT(&loop->watcher_queue);  loop->closing_handles = NULL;  uv__update_time(loop);  uv__async_init(&loop->async_watcher);  loop->signal_pipefd[0] = -1;  loop->signal_pipefd[1] = -1;  loop->backend_fd = -1;  loop->emfile_fd = -1;  loop->timer_counter = 0;  loop->stop_flag = 0;  err = uv__platform_loop_init(loop);  if (err)    return err;  uv_signal_init(loop, &loop->child_watcher);  uv__handle_unref(&loop->child_watcher);  loop->child_watcher.flags |= UV__HANDLE_INTERNAL;  QUEUE_INIT(&loop->process_handles);  if (uv_rwlock_init(&loop->cloexec_lock))    abort();  if (uv_mutex_init(&loop->wq_mutex))    abort();  if (uv_async_init(loop, &loop->wq_async, uv__work_done))    abort();  uv__handle_unref(&loop->wq_async);  loop->wq_async.flags |= UV__HANDLE_INTERNAL;  return 0;}

int main (int argc, char** argv){	int r;	server_param = parse_arguments (argc, argv);	LOG ("Extracting data ...");	training_set = server_extract_data (server_param);	LOG ("Learning ...");	compile_training_set (training_set);	factors = learn (training_set, server_param->model);	factors_backup = copy_learned_factors (factors);	LOG ("Learning completed");	complete = malloc(20 *sizeof(int));	memset(complete,0,20 *sizeof(int));	//parser_settings.on_headers_complete = on_headers_complete;	parser_settings.on_url = on_url;	parser_settings.on_header_value = on_value;	uv_loop = uv_default_loop();	r = uv_tcp_init (uv_loop, &server);	CHECK (r, "bind");	struct sockaddr_in address = uv_ip4_addr ("0.0.0.0", server_param->port);	r = uv_tcp_bind (&server, address);	CHECK (r, "bind");	uv_listen ( (uv_stream_t*) &server, 128, on_connect);	LOGF ("listening on port %u", server_param->port);    	uv_timer_t timer;    	r = uv_timer_init(uv_default_loop(), &timer);    	assert(r == 0);   	r = uv_timer_start(&timer, timer_cb, 10000, 10000);    	assert(r == 0);	  	r = uv_mutex_init(&factors_mutex);  	assert(r == 0);  	r = uv_mutex_init(&factors_backup_mutex);  	assert(r == 0);  	r = uv_mutex_init(&tset_mutex);  	assert(r == 0);	uv_run (uv_loop);}