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

static Chan*consopen(Chan *c, int omode){	c = devopen(c, omode, contab, nelem(contab), devgen);	switch((ulong)c->qid.path) {	case Qconsctl:		incref(&kbd.ctl);		break;	case Qscancode:		qlock(&kbd.gq);		if(gkscanq != nil || gkscanid == nil) {			qunlock(&kbd.q);			c->flag &= ~COPEN;			if(gkscanq)				error(Einuse);			else				error("not supported");		}		gkscanq = qopen(256, 0, nil, nil);		qunlock(&kbd.gq);		break;	case Qkprint:		wlock(&kprintq.l);		if(waserror()){			wunlock(&kprintq.l);			c->flag &= ~COPEN;			nexterror();		}		if(kprintq.q != nil)			error(Einuse);		kprintq.q = qopen(32*1024, Qcoalesce, nil, nil);		if(kprintq.q == nil)			error(Enomem);		qnoblock(kprintq.q, 1);		poperror();		wunlock(&kprintq.l);		c->iounit = qiomaxatomic;		break;	case Qevents:		c->aux = qopen(512, 0, nil, nil);		add_listener(&event_listeners, c->aux);		break;	}	return c;}

void Config::recordQueryPerformance(const std::string& name,                                    size_t delay,                                    size_t size,                                    const Row& r0,                                    const Row& r1) {  WriteLock wlock(config_performance_mutex_);  if (performance_.count(name) == 0) {    performance_[name] = QueryPerformance();  }  // Grab access to the non-const schedule item.  auto& query = performance_.at(name);  BIGINT_LITERAL diff = 0;  if (!r1.at("user_time").empty() && !r0.at("user_time").empty()) {    diff = AS_LITERAL(BIGINT_LITERAL, r1.at("user_time")) -           AS_LITERAL(BIGINT_LITERAL, r0.at("user_time"));    if (diff > 0) {      query.user_time += diff;    }  }  if (!r1.at("system_time").empty() && !r0.at("system_time").empty()) {    diff = AS_LITERAL(BIGINT_LITERAL, r1.at("system_time")) -           AS_LITERAL(BIGINT_LITERAL, r0.at("system_time"));    if (diff > 0) {      query.system_time += diff;    }  }  if (!r1.at("resident_size").empty() && !r0.at("resident_size").empty()) {    diff = AS_LITERAL(BIGINT_LITERAL, r1.at("resident_size")) -           AS_LITERAL(BIGINT_LITERAL, r0.at("resident_size"));    if (diff > 0) {      // Memory is stored as an average of RSS changes between query executions.      query.average_memory = (query.average_memory * query.executions) + diff;      query.average_memory = (query.average_memory / (query.executions + 1));    }  }  query.wall_time += delay;  query.output_size += size;  query.executions += 1;  query.last_executed = getUnixTime();  // Clear the executing query (remove the dirty bit).  setDatabaseValue(kPersistentSettings, kExecutingQuery, "");}

void testObj::test<5>(void){  WaitingLockData     wld;  volatile int        state=0;  auto_ptr<WriteLock> wlock( new WriteLock(mutexRW_) );  assert( wlock.get()!=NULL );  TestThread          tt(&wld, &state, &mutexRW_);  thread              th(tt);  // wait for thread a little  const TimeoutChecker tc(5, "timed out while waiting for state to change");  while( state!=1 && tc() )    boost::thread::yield();  // release lock by setting new value  wld.setPtr( leaf_.shared_ptr() );  // join - if call exited, thread will join cleanly  th.join();}

static int report_title(const char *fmt,...){	int len = 0;	if ( report_fp )	{		wlock(&report_lock);		if ( report_cols++>0 )			len = fprintf(report_fp,"%s",report_eol);		va_list ptr;		va_start(ptr,fmt);		len = +vfprintf(report_fp,fmt,ptr);		va_end(ptr);		fflush(report_fp);		wunlock(&report_lock);	}	return len;}

bool WorldDownloadManager::lockKinfu(){  boost::mutex::scoped_lock wlock(m_kinfu_waiting_mutex);  m_kinfu_waiting_count++;  // wake up the kinfu thread, so "respond" may be called  m_shared_cond.notify_one();  while (!m_kinfu_available && !m_is_shutting_down)    m_kinfu_waiting_cond.wait(wlock);  if (m_is_shutting_down)    return false;  m_kinfu_available = false;  return true;}

/* *  detach a device from an interface, close the interface *  called with ifc->conv closed */static char*ipifcunbind(Ipifc *ifc){	Proc *up = externup();	char *err;	if(waserror()){		wunlock(ifc);		nexterror();	}	wlock(ifc);	/* dissociate routes */	if(ifc->medium != nil && ifc->medium->unbindonclose == 0)		ifc->conv->inuse--;	ifc->ifcid++;	/* disassociate logical interfaces (before zeroing ifc->arg) */	while(ifc->lifc){		err = ipifcremlifc(ifc, ifc->lifc);		/*		 * note: err non-zero means lifc not found,		 * which can't happen in this case.		 */		if(err)			error(err);	}	/* disassociate device */	if(ifc->medium && ifc->medium->unbind)		(*ifc->medium->unbind)(ifc);	memset(ifc->dev, 0, sizeof(ifc->dev));	ifc->arg = nil;	ifc->reassemble = 0;	/* close queues to stop queuing of packets */	qclose(ifc->conv->rq);	qclose(ifc->conv->wq);	qclose(ifc->conv->sq);	ifc->medium = nil;	wunlock(ifc);	poperror();	return nil;}

voidconsinit(void){	int i;	cons.chan = ialloc(sizeof(Chan));	wlock(&cons.chan->reflock);	wunlock(&cons.chan->reflock);	lock(&cons.chan->flock);	unlock(&cons.chan->flock);	dofilter(&cons.work);	dofilter(&cons.rate);	dofilter(&cons.bhit);	dofilter(&cons.bread);	dofilter(&cons.binit);	for(i = 0; i < MAXTAG; i++)		dofilter(&cons.tags[i]);}

int main(){    printf("进程标识(PID): %d/n",getpid());    int fd = open("lock.txt",O_RDWR | O_CREAT | O_TRUNC,0664);    if(fd == -1){        perror("open");        return -1;    }    const char* text = "ABCDEFGHIJKLMNOPQR";    if(write(fd,text,strlen(text) * sizeof(text[0])) == -1){        perror("write");        return -1;    }    //对EFGH加读锁    printf("对EFGH加读锁");    //文件头从0开始    if(rlock(fd,4,4,0) == -1){        printf("失败:%m/n");        return -1;    }    printf("成功!/n");    //对MNOP加写锁    printf("对MNOP加写锁");    if(wlock(fd,12,4,0) == -1){        printf("失败:%m/n");        return -1;    }    printf("成功!/n");    printf("按<回车>，解锁MN...");    getchar();    //解锁MN    ulock(fd,12,2);    printf("按<回车>，解锁EFGH...");    getchar();    //解锁EFGH    ulock(fd,4,4);    /**     * 只要文件描述符一关，什么锁就都没有了。系统内核会自动为你解锁，文件表会被删掉     * 你加的锁也会从v节点表的锁的链表中删掉     * 因为只要文件描述符一关，文件描述符和文件指针的对应就会被删掉，     * 文件表也就没有了，对应v节点表中的锁的链表也就没有了     */    close(fd);    return 0;}

static Chan*envopen(Chan *c, int omode){	Egrp *eg;	Evalue *e;	int trunc;	eg = envgrp(c);	if(c->qid.type & QTDIR) {		if(omode != OREAD)			error(Eperm);	}	else {		trunc = omode & OTRUNC;		if(omode != OREAD && !envwriteable(c))			error(Eperm);		if(trunc)			wlock(&eg->rwl);		else			rlock(&eg->rwl);		e = envlookup(eg, nil, c->qid.path);		if(e == 0) {			if(trunc)				wunlock(&eg->rwl);			else				runlock(&eg->rwl);			error(Enonexist);		}		if(trunc && e->value) {			e->qid.vers++;			free(e->value);			e->value = 0;			e->len = 0;		}		if(trunc)			wunlock(&eg->rwl);		else			runlock(&eg->rwl);	}	c->mode = openmode(omode);	c->flag |= COPEN;	c->offset = 0;	return c;}

Document *Cache::get( const Key &key ){	Status::cacheReqRetain();	wlock();	Document *doc = data[key.str()];	if ( doc && list.front() != doc )	{		std::list<Document*>::iterator it = std::find( list.begin(), list.end(), doc );		list.erase( it );		list.push_front( doc );	}	unlock();	if ( doc )		Status::cacheHitRetain();	return doc;}

voidvoidcache(int n){	Wcache *c;	rlock(&cachelock);	if(c = findcache(n)){		wlock(c);		c->tcurrent = 0;		c->thist = 0;		/* aggressively free memory */		closewhist(c->hist);		c->hist = nil;		closewhist(c->current);		c->current = nil;		wunlock(c);	}	runlock(&cachelock);}

HRESULT SystemProperties::getDefaultAdditionsISO(com::Utf8Str &aDefaultAdditionsISO){    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);    if (m->strDefaultAdditionsISO.isEmpty())    {        /* no guest additions, check if it showed up in the mean time */        alock.release();        {            AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);            ErrorInfoKeeper eik;            (void)setDefaultAdditionsISO("");        }        alock.acquire();    }    aDefaultAdditionsISO = m->strDefaultAdditionsISO;    return S_OK;}

static longenvwrite(Chan *c, void *a, long n, vlong off){	char *s;	ulong len;	Egrp *eg;	Evalue *e;	ulong offset = off;	if(n <= 0)		return 0;	if(offset > Maxenvsize || n > (Maxenvsize - offset))		error(Etoobig);	eg = envgrp(c);	wlock(eg);	if(waserror()){		wunlock(eg);		nexterror();	}	e = envlookup(eg, nil, c->qid.path);	if(e == nil)		error(Enonexist);	len = offset+n;	if(len > e->len) {		s = realloc(e->value, len);		if(s == nil)			error(Enomem);		memset(s+offset, 0, n);		e->value = s;		e->len = len;	}	memmove(e->value+offset, a, n);	e->qid.vers++;	eg->vers++;	wunlock(eg);	poperror();	return n;}

        void renew()        {            com::xiaonei::xce::Statement sql;            sql << "SELECT * FROM " << TABLE_CONFIG;            std::map<std::string, ConfigItemPtr> config;                         BatchDbResultHandler handler(config);             com::xiaonei::xce::QueryRunner(DB_CONFIG, com::xiaonei::xce::CDbRServer).query(sql, handler);                         std::vector<std::string> vecStr;            for(std::map<std::string, ConfigItemPtr>::const_iterator it = config.begin(); it != config.end(); ++it) {                vecStr.push_back(it->first);            }             if(!config.empty()) {                IceUtil::RWRecMutex::WLock wlock(rwMutex_);                config_.swap(config);                dbTableVec_.swap(vecStr);            }        }

PendingCollection::LockedPtr PendingCollection::lockAndWait(    std::chrono::milliseconds timeoutms,    bool& pinged) {  auto lock = wlock();  if (lock->checkAndResetPinged()) {    pinged = true;    return lock;  }  if (timeoutms.count() == -1) {    cond_.wait(lock.getUniqueLock());  } else {    cond_.wait_for(lock.getUniqueLock(), timeoutms);  }  pinged = lock->checkAndResetPinged();  return lock;}

/* *  remove a multicast address from an interface, called with c locked */void ipifcremmulti(struct conv *c, uint8_t * ma, uint8_t * ia){	ERRSTACK(1);	struct Ipmulti *multi, **l;	struct Iplifc *lifc;	struct conv **p;	struct Ipifc *ifc;	struct Fs *f;	f = c->p->f;	for (l = &c->multi; *l; l = &(*l)->next)		if (ipcmp(ma, (*l)->ma) == 0)			if (ipcmp(ia, (*l)->ia) == 0)				break;	multi = *l;	if (multi == NULL)		return;	/* we don't have it open */	*l = multi->next;	for (p = f->ipifc->conv; *p; p++) {		if ((*p)->inuse == 0)			continue;		ifc = (struct Ipifc *)(*p)->ptcl;		if (waserror()) {			wunlock(&ifc->rwlock);			nexterror();		}		wlock(&ifc->rwlock);		for (lifc = ifc->lifc; lifc; lifc = lifc->next)			if (ipcmp(ia, lifc->local) == 0)				remselfcache(f, ifc, lifc, ma);		wunlock(&ifc->rwlock);		poperror();	}	kfree(multi);}

/* *  remove a multicast address from an interface, called with c->car locked */voidipifcremmulti(Conv *c, uint8_t *ma, uint8_t *ia){	Proc *up = externup();	Ipmulti *multi, **l;	Iplifc *lifc;	Conv **p;	Ipifc *ifc;	Fs *f;	f = c->p->f;	for(l = &c->multi; *l; l = &(*l)->next)		if(ipcmp(ma, (*l)->ma) == 0 && ipcmp(ia, (*l)->ia) == 0)			break;	multi = *l;	if(multi == nil)		return; 	/* we don't have it open */	*l = multi->next;	for(p = f->ipifc->conv; *p; p++){		if((*p)->inuse == 0)			continue;		ifc = (Ipifc*)(*p)->ptcl;		if(waserror()){			wunlock(ifc);			nexterror();		}		wlock(ifc);		for(lifc = ifc->lifc; lifc; lifc = lifc->next)			if(ipcmp(ia, lifc->local) == 0)				remselfcache(f, ifc, lifc, ma);		wunlock(ifc);		poperror();	}	free(multi);}

static voidconsclose(Chan *c){	if((c->flag&COPEN) == 0)		return;	switch((ulong)c->qid.path){	case Qconsctl:		/* last close of control file turns off raw */		qlock(&kbd);		if(--kbd.ctl == 0)			kbd.raw = 0;		qunlock(&kbd);		break;	case Qkeyboard:		if(c->mode != OWRITE) {			qlock(&kbd);			--kbd.kbdr;			qunlock(&kbd);		}		break;	case Qscancode:		qlock(&kbd);		if(kscanq) {			qfree(kscanq);			kscanq = 0;		}		qunlock(&kbd);		break;	case Qkprint:		wlock(&kprintq);		qfree(kprintq.q);		kprintq.q = nil;		wunlock(&kprintq);		break;	}}

/* *  detach a device from an interface, close the interface *  called with ifc->conv closed */static char *ipifcunbind(struct Ipifc *ifc){	ERRSTACK(1);	char *err;	if (waserror()) {		wunlock(&ifc->rwlock);		nexterror();	}	wlock(&ifc->rwlock);	/* dissociate routes */	if (ifc->m != NULL && ifc->m->unbindonclose == 0)		ifc->conv->inuse--;	ifc->ifcid++;	/* disassociate device */	if (ifc->m != NULL && ifc->m->unbind)		(*ifc->m->unbind) (ifc);	memset(ifc->dev, 0, sizeof(ifc->dev));	ifc->arg = NULL;	ifc->reassemble = 0;	/* close queues to stop queuing of packets */	qclose(ifc->conv->rq);	qclose(ifc->conv->wq);	qclose(ifc->conv->sq);	/* disassociate logical interfaces */	while (ifc->lifc) {		err = ipifcremlifc(ifc, ifc->lifc);		if (err)			error(err);	}	ifc->m = NULL;	wunlock(&ifc->rwlock);	poperror();	return NULL;}

void FeedMcProxyConsumer::update(const string& shard, const vector<string>& endpoints) {	MCE_INFO("FeedMcProxyConsumer::update --> shard:" << shard);  vector<string> tmp(endpoints);  boost::unique_lock<boost::shared_mutex> wlock(mutex_);  map<string, vector<string> >::iterator it = endpoints_.find(shard);  if (it != endpoints_.end()) { 	  it->second.swap(tmp);		if (!it->second.empty()) {			try {				string endpoints;				for (size_t i = 0; i<it->second.size(); ++i) {					endpoints += it->second[i] + ";";				}				LoadCluster(it->first,endpoints);			} catch(std::exception& e) {				MCE_WARN("FeedMcProxyConsumer::update -->err," << e.what());				}		}  }}

static voidenvremove(Chan *c){	Egrp *eg;	Evalue *e;	if(c->qid.type & QTDIR || !envwriteable(c))		error(Eperm);	eg = envgrp(c);	wlock(eg);	e = envlookup(eg, nil, c->qid.path);	if(e == nil){		wunlock(eg);		error(Enonexist);	}	free(e->name);	free(e->value);	*e = eg->ent[--eg->nent];	eg->vers++;	wunlock(eg);}

voiddevrecover(Device *d){	for (;;) {		print("recover: %Z/n", d);		switch(d->type) {		default:			print("recover: unknown dev type %Z/n", d);			return;		case Devcw:			wlock(&mainlock);	/* recover */			cwrecover(d);			wunlock(&mainlock);			return;		case Devswab:			d = d->swab.d;			break;		}	}}

intcaninsertkey(Intmap *map, ulong id, void *v){	Intlist *f;	int rv;	ulong h;	wlock(map);	if(*llookup(map, id))		rv = 0;	else{		f = emalloc9p(sizeof *f);		f->id = id;		f->aux = v;		h = hashid(id);		f->link = map->hash[h];		map->hash[h] = f;		rv = 1;	}	wunlock(map);	return rv;	}

static int32_tenvwrite(Chan *c, void *a, int32_t n, int64_t off){	char *s;	Egrp *eg;	Evalue *e;	int32_t len, offset;	if(n <= 0)		return 0;	offset = off;	if(offset > Maxenvsize || n > (Maxenvsize - offset))		error(Etoobig);	eg = envgrp(c);	wlock(&eg->rwl);	e = envlookup(eg, nil, c->qid.path);	if(e == 0) {		wunlock(&eg->rwl);		error(Enonexist);	}	len = offset+n;	if(len > e->len) {		s = smalloc(len);		if(e->value){			memmove(s, e->value, e->len);			free(e->value);		}		e->value = s;		e->len = len;	}	memmove(e->value+offset, a, n);	e->qid.vers++;	eg->vers++;	wunlock(&eg->rwl);	return n;}

/** Establish the default timezone for time conversion.	/p NULL /p tzname uses /p TZ environment for default **/char *timestamp_set_tz(char *tz_name){	if (tz_name == NULL){		tz_name=getenv("TZ");	}	if(tz_name == NULL)	{		static char guess[64];		static unsigned int tzlock=0;		if (strcmp(_tzname[0], "") == 0){			THROW("timezone not identified");			/* TROUBLESHOOT				An attempt to use timezones was made before the timezome has been specified.  Try adding or moving the				timezone spec to the top of the <code>clock</code> directive and try again.  Alternatively, you can set the '''TZ''' environment				variable.			 */		}		wlock(&tzlock);		if (_timezone % 60 == 0){			sprintf(guess, "%s%d%s", _tzname[0], (int)(_timezone / 3600), _daylight?_tzname[1]:"");		} else {			sprintf(guess, "%s%d:%d%s", _tzname[0], (int)(_timezone / 3600), (int)(_timezone / 60), _daylight?_tzname[1]:"");		}		if (_timezone==0 && _daylight==0)			tz_name="UTC0";		else			tz_name = guess;		wunlock(&tzlock);	}	load_tzspecs(tz_name);	return current_tzname;}

static bool report_open(void){	wlock(&report_lock);	global_getvar("validate_report",report_file,sizeof(report_file));	if ( report_fp==NULL )	{		report_ext = strrchr(report_file,'.');		if ( strcmp(report_ext,".csv")==0 ) 		{			report_col = ",";			report_eot = "/n";		}		else if ( strcmp(report_ext,".txt")==0) 		{			report_col = "/t";			report_eot = "/n";		}		report_fp = fopen(report_file,"w");	}	wunlock(&report_lock);	return report_fp!=NULL;}