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

/* * Create a new thread based on an existing one. * * The new thread has name NAME, and starts executing in function * ENTRYPOINT. DATA1 and DATA2 are passed to ENTRYPOINT. * * The new thread is created in the process P. If P is null, the * process is inherited from the caller. It will start on the same CPU * as the caller, unless the scheduler intervenes first. */intthread_fork(const char *name,            struct proc *proc,            void (*entrypoint)(void *data1, unsigned long data2),            void *data1, unsigned long data2){    struct thread *newthread;    int result;    newthread = thread_create(name);    if (newthread == NULL) {        return ENOMEM;    }    /* Allocate a stack */    newthread->t_stack = kmalloc(STACK_SIZE);    if (newthread->t_stack == NULL) {        thread_destroy(newthread);        return ENOMEM;    }    thread_checkstack_init(newthread);    /*     * Now we clone various fields from the parent thread.     */    /* Thread subsystem fields */    newthread->t_cpu = curthread->t_cpu;    /* Attach the new thread to its process */    if (proc == NULL) {        proc = curthread->t_proc;    }    result = proc_addthread(proc, newthread);    if (result) {        /* thread_destroy will clean up the stack */        thread_destroy(newthread);        return result;    }    /*     * Because new threads come out holding the cpu runqueue lock     * (see notes at bottom of thread_switch), we need to account     * for the spllower() that will be done releasing it.     */    newthread->t_iplhigh_count++;    spinlock_acquire(&thread_count_lock);    ++thread_count;    wchan_wakeall(thread_count_wchan, &thread_count_lock);    spinlock_release(&thread_count_lock);    /* Set up the switchframe so entrypoint() gets called */    switchframe_init(newthread, entrypoint, data1, data2);    /* Lock the current cpu's run queue and make the new thread runnable */    thread_make_runnable(newthread, false);    return 0;}

void socket_close(struct socket_t* s) {        mutex_lock(s->mutex);        if (s->is_connected) {                s->is_connected = false;        close(s->socket);        s->socket = -1;        if (s->accept_thread != NULL) {            mutex_unlock(s->mutex);            thread_destroy(s->accept_thread);            mutex_lock(s->mutex);            s->accept_thread = NULL;        }                if (s->receive_thread != NULL) {            mutex_unlock(s->mutex);            thread_destroy(s->receive_thread);            mutex_lock(s->mutex);            s->receive_thread = NULL;        }                if (s->callbacks.closed) {            mutex_unlock(s->mutex);            s->callbacks.closed(s, s->callbacks.ctx.closed);            mutex_lock(s->mutex);        }            }        mutex_unlock(s->mutex);    }

int bacstack_session_destroy(bacstack_session_t *session){  return 1       && rwlock_destroy(&session->routetable_lock)      && bacstack_routetable_destroy(&session->routetable)      && pool_destroy(&session->message_pool)      && pool_destroy(&session->proc_pool)      && bacdl_server_destroy(&session->dl_server)      && thread_destroy(&session->msg_proc_thread)      && thread_destroy(&session->dl_accept_thread)      && thread_destroy(&session->dl_receive_thread);}

void free_threads(){	/* free all thread mutex */	thread_destroy(&nuauthdatas->tls_pusher);	thread_destroy(&nuauthdatas->search_and_fill_worker);	thread_list_destroy(nuauthdatas->tls_auth_servers);	thread_list_destroy(nuauthdatas->tls_nufw_servers);	thread_destroy(&nuauthdatas->limited_connections_handler);	if (nuauthconf->push && nuauthconf->hello_authentication) {		thread_destroy(&nuauthdatas->localid_auth_thread);	}}

/* * Last exit routine... * Use global *tty_tmp and terms[] */void g00dbye(void){    write_log(0," g00dbye function called from %d/n",(int)pthread_self());        term_delete_all_tty();    #ifdef HAS_CURSES    if (tty_tmp->interactive && (terms->gui_th.id != 0))       thread_destroy(&terms->gui_th);#endif#ifdef HAVE_GTK    if (tty_tmp->gtk && (terms->gui_gtk_th.id != 0)) {       thread_destroy(&terms->gui_gtk_th);    }#endif#ifdef HAVE_REMOTE_ADMIN    if (tty_tmp->daemonize)       admin_exit();#endif   /* Kill Uptime thread... */   if (terms->uptime_th.id)      thread_destroy_cancel(terms->uptime_th.id);       if (tty_tmp && tty_tmp->term)      free(tty_tmp->term);   /* Destroy interfaces only if they are initialized!! */   if (terms)       interfaces_destroy(&terms->pcap_listen_th);   protocol_destroy();   if (terms)      term_destroy();      if (!tty_tmp->daemonize)   {      write_log(0, " Showing MOTD../n");      show_vty_motd();   }   finish_log();   if (tty_tmp)      free(tty_tmp);   exit(0);}

void grab_blocks()//goes through the routine to pick up the blocks{//starts once near to the pipe, with plowed tribbles; ends back from the pipe, with the tribbles in front, tribble arm down	servo_set(BLOCK_CLAW, BC_CLOSE, .1);//drop the claw	move_block_arm(BLA_DOWN);//	servo_set(BLOCK_CLAW, BC_OPEN, .1);//	time_drive(50,50,1700);//drive up to blocks	servo_set(BLOCK_CLAW, BC_CLOSE,.75);//and pick them up	msleep(250);	move_block_arm(BLA_LIFT);//get off the ground	thread hold=thread_create(hold_ba_lift);//this will hold the block arm at the lift location	thread_start(hold);//	back(6, 60);//back away from the pipe	thread_destroy(hold);//don't want to hold it up any more	servo_set(TRIBBLE_ARM, TA_JUMP, .5);//bring the ta up to keep the blocks in the basket	servo_set(TRIBBLE_CLAW, TC_CLOSE, .5);//	servo_set(TRIBBLE_ARM, TA_UP, .5);//	move_block_arm(BLA_UP);//drop in the basket	msleep(500);	motor(BLOCK_ARM, -50);//stall it into the basket	servo_set(BLOCK_CLAW, BC_OPEN,.75);//	msleep(300);	servo_set(BLOCK_CLAW, BC_START, .4);//shake the claw a bit to try to push the blocks in if they didn't go in the first time	msleep(100);	servo_set(BLOCK_CLAW, BC_OPEN, .75);//	msleep(300);	servo_set(BLOCK_CLAW, BC_START, .4);//	off(BLOCK_ARM);//stop stalling the motor	servo_set(TRIBBLE_CLAW, TC_PART_OPEN, .4);//put the claw back down	servo_set(TRIBBLE_ARM, TA_START, .4);//	msleep(200);	servo_set(TRIBBLE_CLAW, TC_OPEN, .6);//	servo_set(TRIBBLE_ARM, TA_DOWN, .1);//}

static void sys_thread_control(uint32_t *param1, uint32_t *param2){	l4_thread_t dest = param1[REG_R0];	l4_thread_t space = param1[REG_R1];	l4_thread_t pager = param1[REG_R3];	void *utcb = (void *) param2[0];	/* R4 */	mempool_t *utcb_pool = mempool_getbyid(mempool_search((memptr_t) utcb,	                                                      UTCB_SIZE));	if (!utcb_pool || !(utcb_pool->flags & (MP_UR | MP_UW))) {		/* Incorrect UTCB relocation */		return;	}	if (space != L4_NILTHREAD) {		/* Creation of thread */		tcb_t *thr = thread_create(dest, utcb);		thread_space(thr, space, utcb);		thr->utcb->t_pager = pager;		param1[REG_R0] = 1;	}	else {		/* Removal of thread */		tcb_t *thr = thread_by_globalid(dest);		thread_free_space(thr);		thread_destroy(thr);	}}

/* Destroy the threadpool */void thpool_destroy(thpool_* thpool_p){		volatile int threads_total = thpool_p->num_threads_alive;	/* End each thread 's infinite loop */	threads_keepalive = 0;		/* Give one second to kill idle threads */	double TIMEOUT = 1.0;	time_t start, end;	double tpassed = 0.0;	time (&start);	while (tpassed < TIMEOUT && thpool_p->num_threads_alive){		bsem_post_all(thpool_p->jobqueue.has_jobs);		time (&end);		tpassed = difftime(end,start);	}		/* Poll remaining threads */	while (thpool_p->num_threads_alive){		bsem_post_all(thpool_p->jobqueue.has_jobs);		sleep(1);	}	/* Job queue cleanup */	jobqueue_destroy(&thpool_p->jobqueue);		/* Deallocs */	int n;	for (n=0; n < threads_total; n++){		thread_destroy(thpool_p->threads[n]);	}	free(thpool_p->threads);	free(thpool_p);}

void thread_join(thread_t thread, void **result) {  pthread_t *pthread = (pthread_t *)thread;  CHECK_EQ(pthread_join(*pthread, result), 0);  thread_destroy(pthread);}

void rtp_recorder_destroy(struct rtp_recorder_t* rr) {        mutex_lock(rr->timer_mutex);        if (rr->synchronization_thread != NULL) {        condition_signal(rr->timer_cond);        mutex_unlock(rr->timer_mutex);        thread_join(rr->synchronization_thread);        mutex_lock(rr->timer_mutex);        thread_destroy(rr->synchronization_thread);        rr->synchronization_thread = NULL;    }        mutex_unlock(rr->timer_mutex);        rtp_socket_destroy(rr->streaming_socket);    rtp_socket_destroy(rr->control_socket);    rtp_socket_destroy(rr->timing_socket);        sockaddr_destroy(rr->remote_control_end_point);    sockaddr_destroy(rr->remote_timing_end_point);        mutex_destroy(rr->timer_mutex);    condition_destroy(rr->timer_cond);        free(rr);    }

/* ------------------------------------------------------------------- * Any necesary cleanup before Iperf quits. Called at program exit, * either by exit() or terminating main(). * ------------------------------------------------------------------- */void cleanup( void ) {#ifdef WIN32    // Shutdown Winsock    WSACleanup();#endif /* WIN32 */    // clean up the list of clients    Iperf_destroy ( &clients );    // shutdown the thread subsystem    IPERF_DEBUGF( THREAD_DEBUG | IPERF_DBG_TRACE, ( "Deinitializing the thread subsystem./n" ) );    thread_destroy( );    IPERF_DEBUGF( CONDITION_DEBUG | IPERF_DBG_TRACE, ( "Destroying report condition./n" ) );    Condition_Destroy( &ReportCond );    IPERF_DEBUGF( CONDITION_DEBUG | IPERF_DBG_TRACE, ( "Destroying report done condition./n" ) );    Condition_Destroy( &ReportDoneCond );    IPERF_DEBUGF( MUTEX_DEBUG | IPERF_DBG_TRACE, ( "Destroying group condition mutex./n" ) );    Mutex_Destroy( &groupCond );    IPERF_DEBUGF( MUTEX_DEBUG | IPERF_DBG_TRACE, ( "Destroying clients mutex./n" ) );    Mutex_Destroy( &clients_mutex );#ifdef IPERF_DEBUG    debug_init();#endif /* IPERF_DEBUG */} // end cleanup

DECLARE_TEST( atomic, cas ){    int num_threads = 32;    int ithread;    object_t threads[32];    cas_value_t cas_values[32];    for( ithread = 0; ithread < num_threads; ++ithread )    {        threads[ithread] = thread_create( cas_thread, "cas", THREAD_PRIORITY_NORMAL, 0 );        cas_values[ithread].val_32 = ithread;        cas_values[ithread].val_64 = ithread;        cas_values[ithread].val_ptr = (void*)(uintptr_t)ithread;    }    for( ithread = 0; ithread < num_threads; ++ithread )        thread_start( threads[ithread], &cas_values[ithread] );    test_wait_for_threads_startup( threads, num_threads );    for( ithread = 0; ithread < num_threads; ++ithread )        thread_destroy( threads[ithread] );    test_wait_for_threads_exit( threads, num_threads );    EXPECT_EQ( val_32, 0 );    EXPECT_EQ( val_64, 0 );    EXPECT_EQ( val_ptr, 0 );    return 0;}

DECLARE_TEST( error, thread ){	//Launch 32 threads	object_t thread[32];	int i;	for( i = 0; i < 32; ++i )	{		thread[i] = thread_create( error_thread, "error", THREAD_PRIORITY_NORMAL, 0 );		thread_start( thread[i], 0 );	}	test_wait_for_threads_startup( thread, 32 );	test_wait_for_threads_finish( thread, 32 );	for( i = 0; i < 32; ++i )	{		EXPECT_EQ( thread_result( thread[i] ), 0 );		thread_destroy( thread[i] );	}	test_wait_for_threads_exit( thread, 32 );	return 0;}

void profile_enable( bool enable ){	bool was_enabled = ( _profile_enable > 0 );	bool is_enabled = enable;	if( is_enabled && !was_enabled )	{		_profile_enable = 1;		//Start output thread		_profile_io_thread = thread_create( _profile_io, "profile_io", THREAD_PRIORITY_BELOWNORMAL, 0 );		thread_start( _profile_io_thread, 0 );		while( !thread_is_running( _profile_io_thread ) )			thread_yield();	}	else if( !is_enabled && was_enabled )	{		//Stop output thread		thread_terminate( _profile_io_thread );		thread_destroy( _profile_io_thread );		while( thread_is_running( _profile_io_thread ) )			thread_yield();		_profile_enable = 0;	}}

/*  * Kill attack thread pertaining to "node". * If "pid" == 0 then kill *ALL* node attack threads. * Return -1 on error. Return 0 if Ok. */int8_tattack_kill_th(struct term_node *node, pthread_t pid){    u_int16_t i, j;    i = 0;    while (i < MAX_PROTOCOLS)     {        if (protocols[i].visible && node->protocol[i].attacks)        {               j=0;            while (j < MAX_THREAD_ATTACK)             {                if (node->protocol[i].attacks[j].up == 1)                 {                    if (!pid || (node->protocol[i].attacks[j].attack_th.id == pid) )                     {                       thread_destroy(&node->protocol[i].attacks[j].attack_th);                       pthread_mutex_destroy(&node->protocol[i].attacks[j].attack_th.finished);                       if (pid)                           return 0;                    }                }                j++;            }        }        i++;    } /* while protocols...*/        return 0;}

void CGraphicsBackend_Threaded::StopProcessor(){    m_Shutdown = true;    m_Activity.signal();    thread_wait(m_pThread);    thread_destroy(m_pThread);}

DECLARE_TEST( mutex, sync ){	mutex_t* mutex;	object_t thread[32];	int ith;	mutex = mutex_allocate( "test" );	mutex_lock( mutex );	for( ith = 0; ith < 32; ++ith )	{		thread[ith] = thread_create( mutex_thread, "mutex_thread", THREAD_PRIORITY_NORMAL, 0 );		thread_start( thread[ith], mutex );	}	test_wait_for_threads_startup( thread, 32 );	for( ith = 0; ith < 32; ++ith )	{		thread_terminate( thread[ith] );		thread_destroy( thread[ith] );	}	mutex_unlock( mutex );	test_wait_for_threads_exit( thread, 32 );	mutex_deallocate( mutex );	EXPECT_EQ( thread_counter, 32 * 128 );	return 0;}

intmain(int argc, char **argv){  thread_t *threads[2];  list_t   *l;  l = list_new(&g_long_op);  threads[0] = thread_new(NULL, _routine_insert0, (void *) l);  threads[1] = thread_new(NULL, _routine_insert1, (void *) l);  thread_start(threads[0]);  thread_start(threads[1]);  thread_destroy(threads[0], 1);  thread_destroy(threads[1], 1);  list_destroy(l);  return EXIT_SUCCESS;}

static void test_run( void ){	unsigned int ig, gsize, ic, csize;	void* result = 0;#if !BUILD_MONOLITHIC	object_t thread_event = 0;#endif	log_infof( HASH_TEST, "Running test suite: %s", test_suite.application().short_name );	_test_failed = false;#if !BUILD_MONOLITHIC	thread_event = thread_create( test_event_thread, "event_thread", THREAD_PRIORITY_NORMAL, 0 );	thread_start( thread_event, 0 );	while( !thread_is_running( thread_event ) )		thread_yield();#endif	for( ig = 0, gsize = array_size( _test_groups ); ig < gsize; ++ig )	{		log_infof( HASH_TEST, "Running tests from group %s", _test_groups[ig]->name );		for( ic = 0, csize = array_size( _test_groups[ig]->cases ); ic < csize; ++ic )		{			log_infof( HASH_TEST, "  Running %s tests", _test_groups[ig]->cases[ic]->name );			result = _test_groups[ig]->cases[ic]->fn();			if( result != 0 )			{				log_warn( HASH_TEST, WARNING_SUSPICIOUS, "    FAILED" );				_test_failed = true;			}			else			{				log_info( HASH_TEST, "    PASSED" );			}#if BUILD_MONOLITHIC			if( _test_should_terminate )			{				_test_failed = true;				goto exit;			}#endif		}	}#if !BUILD_MONOLITHIC	thread_terminate( thread_event );	thread_destroy( thread_event );	while( thread_is_running( thread_event ) || thread_is_thread( thread_event ) )		thread_yield();#else	exit:#endif	log_infof( HASH_TEST, "Finished test suite: %s", test_suite.application().short_name );}

void event_test(void){	pthread_t threads[2];	assert(0 == event_create(&ev1));	assert(0 == event_create(&ev2));	event_signal(&ev1);	event_reset(&ev1);	thread_create(&threads[0], thread0, NULL);	thread_create(&threads[1], thread1, NULL);	thread_destroy(threads[0]);	thread_destroy(threads[1]);	assert(0 == event_destroy(&ev1));	assert(0 == event_destroy(&ev2));}

static int aio_worker_cleanup(void){	size_t i;	s_running = 0;	for(i = 0; i < MAX_THREAD; i++)		thread_destroy(s_threads[i]);	aio_socket_clean();	return 0;}

/* * Pass nullptr to l4_getid syscall * * This exercise proves that the kernel does not crash * and validly sends a page fault to offending thread's * pager. */int test_getid_nullptr(void){	struct l4_thread *thread;	int err;	/*	 * Create a new thread who will attempt	 * passing null ptr argument	 */	if ((err = thread_create(thread_getid_nullptr,				 0, TC_SHARE_SPACE,				 &thread)) < 0) {		dbg_printf("Thread create failed. "			   "err=%d/n", err);		return err;	}	dbg_printf("Thread created successfully. "		   "tid=%d/n", thread->ids.tid);	/*	 * Listen on thread for its page fault	 * ipc. (Recap: Upon illegal access, the kernel sends	 * a page fault ipc message to thread's pager)	 */	if ((err = l4_receive(thread->ids.tid)) < 0) {		dbg_printf("%s: listening on page fault for "			   "nullptr thread failed. "			   "err = %d/n", __FUNCTION__, err);		return err;	}	/*	 * Verify ipc was a page fault ipc	 */	if (l4_get_tag() != L4_IPC_TAG_PFAULT) {		dbg_printf("%s: Nullptr thread ipc does not "			   "have expected page fault tag./n"			   "tag=%d, expected=%d/n",			   __FUNCTION__, l4_get_tag(),			   L4_IPC_TAG_PFAULT);		return -1;	}	/*	 * Destroy the thread.	 */	if ((err = thread_destroy(thread)) < 0) {		dbg_printf("%s: Failed destroying thread. "			   "err= %d, tid = %d/n",			   __FUNCTION__, err,			   thread->ids.tid);		return err;	}	return 0;}

thread_t thread_create(thread_fn fn, const char *name, void *data) {  pthread_t *pthread = calloc(1, sizeof(pthread_t));  if (pthread_create(pthread, NULL, fn, data)) {    thread_destroy(pthread);    return NULL;  }  return (thread_t)pthread;}

void semaphore_test(void){	pthread_t threads[2];	assert(0 == semaphore_create(&sem1, NULL, 3));	assert(0 == semaphore_create(&sem2, NULL, 0));	assert(0 == semaphore_wait(&sem1));	assert(0 == semaphore_wait(&sem1));	assert(0 == semaphore_trywait(&sem1));	assert(0 != semaphore_trywait(&sem1));	thread_create(&threads[0], thread0, NULL);	thread_create(&threads[1], thread1, NULL);	thread_destroy(threads[0]);	thread_destroy(threads[1]);	printf("all thread exit/n");	assert(0 == semaphore_destroy(&sem1));	assert(0 == semaphore_destroy(&sem2));}

void cleanup( void ) {#ifdef WIN32    // Shutdown Winsock    WSACleanup();#endif    // clean up the list of clients    Iperf_destroy ( &clients );    // shutdown the thread subsystem    thread_destroy( );} // end cleanup

 thread::~thread() {     --*refcnt;     if(*refcnt == 0) {         if(isjoin)             thread_destroy(handle);         delete refcnt;         refcnt = 0;         delete isdone;     } }

void CAStar::OnStateChange(int NewState, int OldState){	if(m_pThread)	{		m_ThreadShouldExit = true;		thread_destroy(m_pThread);		m_pThread = 0;		m_ThreadShouldExit = false;	}	m_Path.clear();}

/* * Clean up zombies. (Zombies are threads that have exited but still * need to have thread_destroy called on them.) * * The list of zombies is per-cpu. */staticvoidexorcise(void){	struct thread *z;	while ((z = threadlist_remhead(&curcpu->c_zombies)) != NULL) {		KASSERT(z != curthread);		KASSERT(z->t_state == S_ZOMBIE);		thread_destroy(z);	}}