static int wrap_pthread_key_delete(pthread_key_t key)
{
    /* this is clumsy: having to key_create lessens key_delete's chances
       of being interrupted - test not definite */
    int err2;
    WRAP_START
    while(
        !(err2 = pthread_key_create(&key, NULL))
        &&
        !(err  = pthread_key_delete(key))
    );
    if (err2)
        err = -3; //meaning the dependecy failed
    WRAP_END
}

static void
_MXML_FINI(void)
{
  _mxml_global_t	*global;	/* Global data */


  if (_mxml_key != -1)
  {
    if ((global = (_mxml_global_t *)pthread_getspecific(_mxml_key)) != NULL)
      _mxml_destructor(global);

    pthread_key_delete(_mxml_key);
    _mxml_key = -1;
  }
}

int tMPI_Thread_key_delete(tMPI_Thread_key_t key)
{
    int ret;

    ret=pthread_key_delete((key.key->pkey));
    free(key.key);

    if(ret!=0)
    {
        tMPI_Fatal_error(TMPI_FARGS,"Failed to delete thread key, rc=%d.",ret);
        fflush(stderr);
    }
    
    return ret;
}

void delete_msgque(void  *arg)
{
	msgque_t que = (msgque_t)arg;
    lnode *n;
	if(que->destroy_function){
        while((n = LLIST_POP(lnode*,&que->share_que))!=NULL)
			que->destroy_function((void*)n);
	}
	mutex_destroy(&que->mtx);
	pthread_key_delete(que->t_key);
	free(que);
#ifdef _DEBUG
	printf("on_que_destroy\n");
#endif
}

bool OS_FreeTLSIndex(OS_TLSIndex nIndex)
{
	if (nIndex == OS_INVALID_TLS_INDEX) {
		assert(0 && "OS_SetTLSValue(): Invalid TLS Index");
		return false;
	}

	//
	// Delete the global pool key.
	//
	if (pthread_key_delete(nIndex) == 0)
		return true;
	else
		return false;
}

rtems_task Test_Thread( rtems_task_argument arg )
{
  void *argument = (void *) arg;
  int sc;

  puts( "Test_Thread - key pthread_setspecific - OK" );
  sc = pthread_setspecific( key, argument );
  rtems_test_assert( !sc );

  puts( "Test_Thread - pthread key delete - OK" );
  sc = pthread_key_delete( key );
  rtems_test_assert( sc == 0 );

  puts( "Test_Thread - exit but don't run key destructors - OK" );
  rtems_task_delete( RTEMS_SELF );
}

MachineThreads::~MachineThreads()
{
#if ENABLE(JSC_MULTIPLE_THREADS)
    if (m_threadSpecific) {
        int error = pthread_key_delete(m_threadSpecific);
        ASSERT_UNUSED(error, !error);
    }

    MutexLocker registeredThreadsLock(m_registeredThreadsMutex);
    for (Thread* t = m_registeredThreads; t;) {
        Thread* next = t->next;
        delete t;
        t = next;
    }
#endif
}

/** stop checklocks */
void checklock_stop(void)
{
	if(key_created) {
		int i;
		key_deleted = 1;
		if(check_locking_order)
			fclose(thread_infos[0]->order_info);
		free(thread_infos[0]);
		thread_infos[0] = NULL;
		for(i = 0; i < THRDEBUG_MAX_THREADS; i++)
			log_assert(thread_infos[i] == NULL);
			/* should have been cleaned up. */
		LOCKRET(pthread_key_delete(thr_debug_key));
		key_created = 0;
	}
}

static int wrap_pthread_key_create(pthread_key_t *key,
                                   void (*destructor)(void*))
{
    /* this is clumsy: having to key_create lessens key_delete's chances
       of being interrupted - test not definite */
    int err2;
    WRAP_START
    while(
        !(err  = pthread_key_create(key, destructor))
        &&
        !(err2 = pthread_key_delete(*key))
    );
    if (!err && err2)
        err = -3; //meaning the dependecy failed
    WRAP_END
}

JNIEXPORT void JNICALL
JNI_OnUnload(JavaVM *jvm, void *reserved)
{
    JNIEnv *env;

    destroy_native_crash_handler();

    if (jvm->GetEnv((void **) &env, JNI_VERSION))
        return;

    env->DeleteGlobalRef(gfq.clazz);
    env->DeleteGlobalRef(gfq.String.clazz);
    env->DeleteGlobalRef(gfq.IllegalArgumentException.clazz);

    pthread_key_delete(jni_env_key);
}

/**
 * Simple holder of work-arounds for link-time issues.
 */
void workaroundHook()
{
    pthread_key_t key = {0};
    int ret = pthread_key_create(&key, NULL);
    if (!ret)
    {
        void *ptr = pthread_getspecific(key); // should return NULL
        ret = pthread_setspecific(key, &ptr);
        if (ret)
        {
            // Something went wrong. Since this is a stub, we don't care.
        }

        pthread_key_delete(key);
    }
}

int main(void)
{
	pthread_t thid1;
	int status;
	
	pthread_key_create(&keyid,NULL);
	
	if (pthread_create(&thid1,NULL,(void *)func2,NULL))
		printf("创建线程1失败\n");

	printf("主线程:%lu\n",pthread_self());
	pthread_join(thid1,(void *)&status);
	pthread_key_delete(keyid);

	return 0;
}

void PoolMemoryAllocator::cleanup()
{
	BlockChainPtr p = s_blocks;
	while(p != 0) {
		BlockChainPtr pNext = p->m_next;
		free(p);
		p = pNext;
	}

#ifndef OGDF_MEMORY_POOL_NTS
#ifdef OGDF_NO_COMPILER_TLS
	pthread_key_delete(s_tpKey);
#endif
	delete s_criticalSection;
#endif
}

void git_threads_shutdown(void)
{
	if (_tls_init) {
		void *ptr = pthread_getspecific(_tls_key);
		pthread_setspecific(_tls_key, NULL);
		git__free(ptr);
	}

	pthread_key_delete(_tls_key);
	_tls_init = 0;
	git_mutex_free(&git__mwindow_mutex);

	/* Shut down any subsystems that have global state */
	git_hash_global_shutdown();
	git_futils_dirs_free();
}

int main()
{
    pthread_t tid[THREAD_NUM];
    int i;
    pthread_key_create(&key, NULL);

#pragma omp parallel for
    for ( i = 0; i < THREAD_NUM; i++ )
        pthread_create(&tid[i], NULL, thread, NULL);
#pragma omp parallel for
    for ( i = 0; i < THREAD_NUM; i++ )
        pthread_join(tid[i], NULL);

    pthread_key_delete(key);
    return 0;
}

/* Shutdown TSRM (call once for the entire process) */
TSRM_API void tsrm_shutdown(void)
{
	int i;

	if (tsrm_tls_table) {
		for (i=0; i<tsrm_tls_table_size; i++) {
			tsrm_tls_entry *p = tsrm_tls_table[i], *next_p;

			while (p) {
				int j;

				next_p = p->next;
				for (j=0; j<p->count; j++) {
					if (p->storage[j]) {
						if (resource_types_table && !resource_types_table[j].done && resource_types_table[j].dtor) {
							resource_types_table[j].dtor(p->storage[j], &p->storage);
						}
						free(p->storage[j]);
					}
				}
				free(p->storage);
				free(p);
				p = next_p;
			}
		}
		free(tsrm_tls_table);
		tsrm_tls_table = NULL;
	}
	if (resource_types_table) {
		free(resource_types_table);
		resource_types_table=NULL;
	}
	tsrm_mutex_free(tsmm_mutex);
	tsmm_mutex = NULL;
	TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Shutdown TSRM"));
	if (tsrm_error_file!=stderr) {
		fclose(tsrm_error_file);
	}
#if defined(GNUPTH)
	pth_kill();
#elif defined(PTHREADS)
	pthread_setspecific(tls_key, 0);
	pthread_key_delete(tls_key);
#elif defined(TSRM_WIN32)
	TlsFree(tls_key);
#endif
}

int
do_test (void)
{
  pthread_key_t keys[N];

  int i;
  for (i = 0; i < N; ++i)
    if (pthread_key_create (&keys[i], fcts[i]) != 0)
      {
	write (2, "key_create failed\n", 18);
	_exit (1);
      }

  pthread_t th;
  if (pthread_create (&th, NULL, tf, &keys[1]) != 0)
    {
      write (2, "create failed\n", 14);
      _exit (1);
    }

  if (pthread_join (th, NULL) != 0)
    {
      write (2, "join failed\n", 12);
      _exit (1);
    }

  if (cnt0 != 0)
    {
      write (2, "cnt0 != 0\n", 10);
      _exit (1);
    }

  if (cnt1 != 1)
    {
      write (2, "cnt1 != 1\n", 10);
      _exit (1);
    }

  for (i = 0; i < N; ++i)
    if (pthread_key_delete (keys[i]) != 0)
      {
	write (2, "key_delete failed\n", 18);
	_exit (1);
      }

  return 0;
}

int di_rwlock_destroy(di_rwlock_t * self) {
    int retval;
    if (dirw == NULL) return EINVAL;

    retval = pthread_mutex_destroy(&self->writers_mutex);
    if (retval != 0) return retval;
    retval = pthread_rwlock_destroy(&self->rwlock1);
    if (retval != 0) return retval;
    retval = pthread_rwlock_destroy(&self->rwlock2);
    if (retval != 0) return retval;
    retval = pthread_key_delete(self->key);
    if (retval != 0) return retval;

    self->instance1 = NULL;
    self->instance2 = NULL;
    return 0;
}

int main(void)
{
        int tid1,tid2;
        int cycle = 100;
        pthread_key_create(&key,NULL);
        
        while(cycle--)
        {
          pthread_create(&tid1,NULL,child1,NULL);
          pthread_create(&tid2,NULL,child2,NULL);
        }
        sleep(10);
        pthread_key_delete(key);

        printf("main thread exit\n");
        return 0;
}

/* 关闭log文件 */
int
close_logger(int thread_num)
{
    int i, ret;
    /* 关闭log文件 */
    for (i = 0; i < thread_num; i++)
    {
        if (log_file[i]) {
            ret = fclose(log_file[i]);
            log_file[i] = NULL;
        }
    }

    /* 删除log id变量 */
    pthread_key_delete(log_id);
    return ret;
}