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

int main(int argc, char** argv) {	//printf("Thread %d bootting/n", thread_id());	if(thread_id() == 0) {		ginit(argc, argv);	}		thread_barrior();		init(argc, argv);		thread_barrior();		printf("PacketNgin APP Start/n");		perf();	perf();	perf();	/*	uint32_t i = 0;	while(1) {		uint32_t count = ni_count();		if(count > 0) {			i = (i + 1) % count;						NetworkInterface* ni = ni_get(i);			if(ni_has_input(ni)) {				process(ni);			}		}	}	*/		thread_barrior();		destroy();		thread_barrior();		if(thread_id() == 0) {		gdestroy(argc, argv);	}	while(1);		return 0;}

int main(int argc, char** argv) {	printf("Test %d/n", argc);	printf("Thread %d booting/n", thread_id());	if(thread_id() == 0) {		ginit(argc, argv);	}		thread_barrior();		init(argc, argv);		thread_barrior();		char key[] = "password";	char message[] = "Hello World";		printf("Plain text: ");	for(int i = 0; i < sizeof(message); i++) {		printf("%02x", message[i]);	}	printf("/n");		char* encrypted = Encrypt(key, message, sizeof(message));	printf("Encry text: ");	for(int i = 0; i < sizeof(message); i++) {		printf("%02x", encrypted[i]);	}	printf("/n");		char* decrypted = Decrypt(key, encrypted, sizeof(message));	printf("Decry text: ");	for(int i = 0; i < sizeof(message); i++) {		printf("%02x", decrypted[i]);	}	printf("/n");		thread_barrior();		destroy();		thread_barrior();		if(thread_id() == 0) {		gdestroy(argc, argv);	}		return 0;}

/*-------------------------------------------------------------------*/static void sigint_handler (int signo){//  logmsg ("impl.c: sigint handler entered for thread %lu/n",/*debug*///          thread_id());                                     /*debug*/    UNREFERENCED(signo);    signal(SIGINT, sigint_handler);    /* Ignore signal unless presented on console thread */    if ( !equal_threads( thread_id(), sysblk.cnsltid ) )        return;    /* Exit if previous SIGINT request was not actioned */    if (sysblk.sigintreq)    {        /* Release the configuration */        release_config();        delayed_exit(1);    }    /* Set SIGINT request pending flag */    sysblk.sigintreq = 1;    /* Activate instruction stepping */    sysblk.inststep = 1;    SET_IC_TRACE;    return;} /* end function sigint_handler */

 void dispatch(F fun) {   if (std::this_thread::get_id() == thread_id()) {     fun();     return;   }   post(std::move(fun)); }

boolmutex_unlock(mutex_t* mutex) {	if (!mutex->lockcount) {		log_warnf(0, WARNING_SUSPICIOUS, STRING_CONST("Unable to unlock unlocked mutex %.*s"),		          (int)mutex->name.length, mutex->name.str);		return false;	}	FOUNDATION_ASSERT(mutex->lockedthread == thread_id());	--mutex->lockcount;#if !BUILD_DEPLOY	profile_unlock(mutex->name.str, mutex->name.length);#endif#if FOUNDATION_PLATFORM_WINDOWS	LeaveCriticalSection((CRITICAL_SECTION*)mutex->csection);#elif FOUNDATION_PLATFORM_POSIX || FOUNDATION_PLATFORM_PNACL	if (pthread_mutex_unlock(&mutex->mutex) != 0) {		FOUNDATION_ASSERT_FAILFORMAT("unable to unlock mutex %s", mutex->name.str);		return false;	}#else#  error mutex_unlock not implemented#endif	return true;}

char *nast_errmsg(nasth *s){	nast_response *ar;	errcodes ec;	ec = nast_geterr(s);	if (ec == NAST_SERVER_ERR) {		nast_array *aa;		ar = getmyresponse(s, thread_id());		if (ar == NULL)			return nast_errmsgs[NAST_UNKNOWN_RESPONSE];		aa = build_result(s, ar->buffer, ar->bufflen);		if (aa == NULL || aa->nitems == 0)			return nast_errmsgs[NAST_UNKNOWN_RESPONSE];		if (ar->errmsg != NULL)			free(ar->errmsg);		ar->errmsg = malloc(aa->items[0]->strlen);		if (ar->errmsg == NULL)			return nast_errmsgs[NAST_UNKNOWN_RESPONSE];		memcpy(ar->errmsg, aa->items[0]->strdata, aa->items[0]->strlen);		nast_free_result(aa);		return ar->errmsg;	}	return nast_errmsgs[ec];}

  void MemoryHeader::unlock(STATE) {    while(true) {      MemoryFlags h = header.load(std::memory_order_acquire);      if(thread_id() == state->vm()->thread_id()) {        if(extended_header_p()) {          ExtendedHeader* hh = extended_header();          if(hh->lock_extended_p()) {            hh->get_lock()->unlock(state);            return;          } else {            int locked_count = locked_count_field.get(hh->header);            if(locked_count > 0) {              ExtendedHeader* eh = ExtendedHeader::create_copy(                  locked_count_field.set(hh->header, locked_count - 1), hh);              MemoryFlags nh = extended_flags(eh);              if(header.compare_exchange_strong(h, nh, std::memory_order_release)) {                return;              }              eh->delete_header();            } else {              Exception::raise_runtime_error(state,                  "unlocking owned, extended-header, non-locked object");            }          }        } else {          int locked_count = locked_count_field.get(h);          if(locked_count > 0) {            MemoryFlags nh = locked_count_field.set(h, locked_count - 1);            if(header.compare_exchange_strong(h, nh, std::memory_order_release)) {              return;            }          } else {            Exception::raise_runtime_error(state, "unlocking owned, non-locked object");          }        }      } else {        if(extended_header_p()) {          ExtendedHeader* hh = extended_header();          if(hh->lock_extended_p()) {            hh->get_lock()->unlock(state);            return;          } else {            Exception::raise_runtime_error(state,                "unlocking non-owned, extended-header, non-locked object");          }        } else {          Exception::raise_runtime_error(state, "unlocking non-owned, non-locked object");        }      }    }  }

static void _log_outputf( uint64_t context, int severity, const char* prefix, const char* format, va_list list, void* std ){	log_timestamp_t timestamp = _log_make_timestamp();	uint64_t tid = thread_id();	unsigned int pid = thread_hardware();	int need, more, remain, size = 383;	char local_buffer[385];	char* buffer = local_buffer;	while(1)	{		//This is guaranteed to always fit in minimum size of 383 bytes defined above, so need is always > 0		if( _log_prefix )			need = snprintf( buffer, size, "[%u:%02u:%02u.%03u] <%" PRIx64 ":%d> %s", timestamp.hours, timestamp.minutes, timestamp.seconds, timestamp.milliseconds, tid, pid, prefix );		else			need = snprintf( buffer, size, "%s", prefix );		remain = size - need;		{			va_list clist;			va_copy( clist, list );			more = vsnprintf( buffer + need, remain, format, clist );			va_end( clist );		}					if( ( more > -1 ) && ( more < remain ) )		{			buffer[need+more] = '/n';			buffer[need+more+1] = 0;#if FOUNDATION_PLATFORM_WINDOWS			OutputDebugStringA( buffer );#endif#if FOUNDATION_PLATFORM_ANDROID			if( _log_stdout )				__android_log_write( ANDROID_LOG_DEBUG + severity - 1, environment_application()->short_name, buffer );#else			if( _log_stdout && std )				fprintf( std, "%s", buffer );#endif			if( _log_callback )				_log_callback( context, severity, buffer );			break;		}		if( ( more > -1 ) && ( need > -1 ) )			size = more + need + 1;		else			size *= 2;		if( buffer != local_buffer )			memory_deallocate( buffer );		buffer = memory_allocate( size + 2, 0, MEMORY_TEMPORARY );	}	if( buffer != local_buffer )		memory_deallocate( buffer );}

factor_vm* new_factor_vm() {  THREADHANDLE thread = thread_id();  factor_vm* newvm = new factor_vm(thread);  register_vm_with_thread(newvm);  thread_vms[thread] = newvm;  return newvm;}

void profile_begin_block( const char* message ){	uint32_t parent;	if( !_profile_enable )		return;	parent = get_thread_profile_block();	if( !parent )	{		//Allocate new master block		profile_block_t* block = _profile_allocate_block();		uint32_t blockindex;		if( !block )			return;		blockindex = BLOCK_INDEX( block );		block->data.id = atomic_add32( &_profile_counter, 1 );		string_copy( block->data.name, message, MAX_MESSAGE_LENGTH );		block->data.processor = thread_hardware();		block->data.thread = (uint32_t)thread_id();		block->data.start  = time_current() - _profile_ground_time;		set_thread_profile_block( blockindex );	}	else	{		//Allocate new child block		profile_block_t* parentblock;		profile_block_t* subblock = _profile_allocate_block();		uint32_t subindex;		if( !subblock )			return;		subindex = BLOCK_INDEX( subblock );		parentblock = GET_BLOCK( parent );		subblock->data.id = atomic_add32( &_profile_counter, 1 );		subblock->data.parentid = parentblock->data.id;		string_copy( subblock->data.name, message, MAX_MESSAGE_LENGTH );		subblock->data.processor = thread_hardware();		subblock->data.thread = (uint32_t)thread_id();		subblock->data.start  = time_current() - _profile_ground_time;		subblock->previous = parent;		subblock->sibling = parentblock->child;		if( parentblock->child )			GET_BLOCK( parentblock->child )->previous = subindex;		parentblock->child = subindex;		set_thread_profile_block( subindex );	}}

factor_vm *new_factor_vm(){	factor_vm *newvm = new factor_vm();	register_vm_with_thread(newvm);	thread_vms[thread_id()] = newvm;	return newvm;}

int _thread_id(int *id) {	if (!id) {		return ERR_MALLOC;	}	*id = thread_id(NULL);	return 0;}

	virtual void* run()	{		const char* myname = "run";		printf("%s: thread id: %lu, %lu/r/n",			myname, thread_id(), acl::thread::thread_self());		if (auto_destroy_)			delete this;		return NULL;	}

int main(int argc, char** argv) {	printf("Thread %d booting/n", thread_id());	if(thread_id() == 0) {		ginit(argc, argv);	}	thread_barrior();		init(argc, argv);		thread_barrior();	//char name[128] = { 0, };	char *name;	printf("Input your name: ");	//fflush(stdout);	while(1) {		//int len = scanf("%s", name);		name = readline();		printf("readline()/n");		if(name){			printf("%s/n", name);		}		int len = strlen(name);		printf("%s/n", name);		if(len > 0) {			printf("%d out> Hello %s from thread %d/n", len, name, thread_id());			//fprintf(stdout, "%d out> Hello %s from thread %d/n", len, name, thread_id());			//fprintf(stderr, "%d err> Hello %s from thread %d/n", len, name, thread_id());			fflush(stdout);		}	}		thread_barrior();		destroy();		thread_barrior();		if(thread_id() == 0) {		gdestroy(argc, argv);	}		return 0;}

static intfact(int n){	/* store address of some variable on stack */	stack_array[thread_id()] = (long *)&n;	if (n == 1) {		return 1;	}	return n * fact(n - 1);}

DLL_EXPORT void ptt_pthread_trace (int trclass, char * type, void *data1, void *data2,                        char *loc, int result){int i, n;    if (pttrace == NULL || pttracen == 0 || !(pttclass & trclass) ) return;    /*    ** Fish debug: it appears MSVC sometimes sets the __FILE__ macro    ** to a full path filename (rather than just the filename only)    ** under certain circumstances. (I think maybe it's only for .h    ** files since vstore.h is the one that's messing up). Therefore    ** for MSVC we need to convert it to just the filename. ((sigh))    */#if defined( _MSVC_ )   // fish debug; appears to be vstore.h                        // maybe all *.h files are this way??    {        char* p = strrchr( loc, '//' );        if (!p) p = strrchr( loc, '/' );        if (p)            loc = p+1;    }#endif    /*     * Messages from timer.c, clock.c and/or logger.c are not usually     * that interesting and take up table space.  Check the flags to     * see if we want to trace them.     */    if (!strncasecmp(loc, "timer.c:", 8)  && !(pttclass & PTT_CL_TMR)) return;    if (!strncasecmp(loc, "clock.c:", 8)  && !(pttclass & PTT_CL_TMR)) return;    if (!strncasecmp(loc, "logger.c:", 9) && !(pttclass & PTT_CL_LOG)) return;    /* check for `nowrap' */    if (pttnowrap && pttracex + 1 >= pttracen) return;    OBTAIN_PTTLOCK;    if (pttrace == NULL || (n = pttracen) == 0)    {        RELEASE_PTTLOCK;        return;    }    i = pttracex++;    if (pttracex >= n) pttracex = 0;    RELEASE_PTTLOCK;    pttrace[i].tid   = thread_id();    pttrace[i].trclass = trclass;    pttrace[i].type  = type;    pttrace[i].data1 = data1;    pttrace[i].data2 = data2;    pttrace[i].loc  = loc;    if (pttnotod == 0)        gettimeofday(&pttrace[i].tv,NULL);    pttrace[i].result = result;}

nast_array *nast_get_result(nasth *s){	nast_response *ar;	ar = getmyresponse(s, thread_id());	if (ar == NULL)		return NULL;	return build_result(s, ar->buffer, ar->bufflen);}

 void define_formatters(Writer& writer) {     writer.replace_formatter("osthread", shepherd_thread_id());     writer.replace_formatter("locality", locality_prefix());     writer.replace_formatter("hpxthread", thread_id());     writer.replace_formatter("hpxphase", thread_phase());     writer.replace_formatter("hpxparent", parent_thread_id());     writer.replace_formatter("hpxparentphase", parent_thread_phase());     writer.replace_formatter("parentloc", parent_thread_locality());     writer.replace_formatter("hpxcomponent", thread_component_id()); }

		PROCESS_INFORMATION ScopedProcessInformation::Take() {			PROCESS_INFORMATION process_information = {};			process_information.hProcess = process_handle_.Take();			process_information.hThread = thread_handle_.Take();			process_information.dwProcessId = process_id();			process_information.dwThreadId = thread_id();			process_id_ = 0;			thread_id_ = 0;			return process_information;		}

static intadd_reqid(char *buffer){	unsigned short tid, n_tid;	tid = thread_id();	n_tid = htons(tid);	memcpy(buffer, &n_tid, sizeof(tid));	return sizeof(tid);}

/*-------------------------------------------------------------------*/static int  hthread_getschedprio( TID tid ){    int prio, dummy;    struct sched_param  param;    memset( &param, 0, sizeof( param ));    if (equal_threads(tid,0))        tid = thread_id();    prio = (hthread_getschedparam( tid, &dummy, &param ) == 0) ?        param.sched_priority : INT_MAX;    return prio;}

/*-------------------------------------------------------------------*/static int  hthread_setschedprio( TID tid, int prio ){    int rc;    struct sched_param param;    memset( &param, 0, sizeof( param ));    if (equal_threads(tid,0))        tid = thread_id();    param.sched_priority = prio;    rc = hthread_setschedparam( tid, herc_policy, &param );    return rc;}

/* thread to print trace after timeout */void *ptt_timeout(){    struct timeval  now;    struct timespec tm;    WRMSG(HHC00100, "I", (u_long)thread_id(), getpriority(PRIO_PROCESS,0),"PTT timeout timer");    obtain_lock (&ptttolock);    gettimeofday (&now, NULL);    tm.tv_sec = now.tv_sec + pttto;    tm.tv_nsec = now.tv_usec * 1000;    timed_wait_condition (&ptttocond, &ptttolock, &tm);    if (thread_id() == ptttotid)    {        ptt_pthread_print();        pttto = 0;        ptttotid = 0;    }    release_lock (&ptttolock);    WRMSG(HHC00101, "I", (u_long)thread_id(), getpriority(PRIO_PROCESS,0), "PTT timeout timer");    return NULL;}

int InputModule::recordstart(lua_State* L, int idx){  InputList* list = (InputList*) lua_touserdata(L, idx);  if (list->getrecording() == 0)  {    lua_pushvalue(L, idx);    uint32 id = luaL_ref(L, LUA_REGISTRYINDEX);    list->setrecording(id);    PostThreadMessage(thread_id(), IM_ADDRECORD, id, 0);  }  return 0;}

/*---------------------------------------------------------------------------*/static void* hao_thread(void* dummy){  char*  msgbuf  = NULL;  int    msgidx  = -1;  int    msgamt  = 0;  char*  msgend  = NULL;  char   svchar  = 0;  int    bufamt  = 0;  UNREFERENCED(dummy);  logmsg(HHCAO001I, thread_id(), getpriority(PRIO_PROCESS,0), getpid());  /* Wait for panel thread to engage */  while (!sysblk.panel_init && !sysblk.shutdown)    usleep( 10 * 1000 );  /* Do until shutdown */  while (!sysblk.shutdown && msgamt >= 0)  {    /* wait for message data */    if ((msgamt = log_read(&msgbuf, &msgidx, LOG_BLOCK)) > 0 )    {      /* append to existing data */      if (msgamt > (int)((sizeof(ao_msgbuf) - 1) - bufamt) )          msgamt = (int)((sizeof(ao_msgbuf) - 1) - bufamt);      strncpy( &ao_msgbuf[bufamt], msgbuf, msgamt );      ao_msgbuf[bufamt += msgamt] = 0;      msgbuf = ao_msgbuf;      /* process only complete messages */      while (NULL != (msgend = strchr(msgbuf,'/n')))      {        /* null terminate message */        svchar = *(msgend+1);        *(msgend+1) = 0;        /* process message */        hao_message(msgbuf);        /* restore destroyed byte */        *(msgend+1) = svchar;        msgbuf = msgend+1;      }      /* shift message buffer */      memmove( ao_msgbuf, msgbuf, bufamt -= (msgbuf - ao_msgbuf) );    }  }  logmsg(HHCAO002I);  return NULL;}

/*-------------------------------------------------------------------*/void* socket_thread( void* arg ){    int     rc;    fd_set  sockset;    int     maxfd = 0;    int     select_errno;    int     exit_now;    UNREFERENCED( arg );    /* Display thread started message on control panel */    logmsg (_("HHCSD020I Socketdevice listener thread started: "            "tid="TIDPAT", pid=%d/n"),            thread_id(), getpid());    for (;;)    {        /* Set the file descriptors for select */        FD_ZERO ( &sockset );        maxfd  = add_socket_devices_to_fd_set (   0,   &sockset );        SUPPORT_WAKEUP_SOCKDEV_SELECT_VIA_PIPE( maxfd, &sockset );        /* Do the select and save results */        rc = select ( maxfd+1, &sockset, NULL, NULL, NULL );        select_errno = HSO_errno;        /* Clear the pipe signal if necessary */        RECV_SOCKDEV_THREAD_PIPE_SIGNAL();        /* Check if it's time to exit yet */        obtain_lock( &bind_lock );        exit_now = ( sysblk.shutdown || IsListEmpty( &bind_head ) );        release_lock( &bind_lock );        if ( exit_now ) break;        /* Log select errors */        if ( rc < 0 )        {            if ( HSO_EINTR != select_errno )                logmsg( _( "HHCSD021E select failed; errno=%d: %s/n"),                    select_errno, strerror( select_errno ) );            continue;        }        /* Check if any sockets have received new connections */        check_socket_devices_for_connections( &sockset );    }    logmsg( _( "HHCSD022I Socketdevice listener thread terminated/n" ) );    return NULL;}

intManager::shut_down (void){  ACE_TRACE (ACE_TEXT ("Manager::shut_down"));  ACE_Unbounded_Queue<Worker* >::ITERATOR iter =    this->workers_.begin ();  Worker **worker_ptr = NULL;  do    {      iter.next (worker_ptr);      Worker *worker = (*worker_ptr);      ACE_DEBUG ((LM_DEBUG,                 ACE_TEXT ("(%t) Attempting shutdown of %d/n"),                 thread_id (worker)));      // Send the hangup message.      ACE_Message_Block *mb;      ACE_NEW_RETURN        (mb,         ACE_Message_Block(0,                           ACE_Message_Block::MB_HANGUP),         -1);      worker->putq (mb);      // Wait for the exit.      worker->wait ();      ACE_ASSERT (worker->msg_queue ()->is_empty ());      ACE_DEBUG ((LM_DEBUG,                  ACE_TEXT ("(%t) Worker %d shut down./n)"),                  thread_id (worker)));      delete worker;    }  while (iter.advance ());  shutdown_ = 1;  return 0;}

int main(int argc, char** argv) {	printf("Thread %d booting/n", thread_id());	if(thread_id() == 0) {		time_init();		event_init();		ginit(argc, argv);	}		thread_barrior();		init(argc, argv);		thread_barrior();	/* Start of User Code Area */	int fd;	file_init();	file_opendir("/", open_cb, &fd);	if(thread_id() == 0) {		while(1) {			event_loop();		}	}	/* End of User Code Area */	thread_barrior();		destroy();		thread_barrior();		if(thread_id() == 0) {		gdestroy(argc, argv);	}		return 0;}