pthread_key_create 会导致内存泄漏吗？

Question

I have a program that has a static pthread_key_t key variable and a function that calls pthread_key_create(&key, &cleanup_function) when the first thread is started. I don't want to call pthread_key_delete in the cleanup routine because it will run whenever a thread exits instead of when all threads have exited. This will cause problems if another thread calls get_specific or set_specific later on. My question is: Can I just completely leave out pthread_key_delete ? Will this (having called pthread_key_create without calling pthread_key_delete afterward) cause any memory leak when the program eventually comes to a halt? Is it mandatory to call pthread_key_delete after creating a pthread_key_t? Or does the key just go into the garbage collector or get destructed once the entire problem ends?

static pthread_key_t key = NULL;

...
static void cleanup(void *value) {
  ...
  if (thread_exit_callback) {
    thread_exit_callback(value);
  }
  free(value);
}

static void *start(void *value) {
  ...
  if (key == NULL){
    pthread_key_create(&key, &cleanup);
  }
  pthread_setspecific(key, value);
  ...
}

The program looks something like this.

Answer 1

I have a program that has a static pthread_key_t key variable and a function that calls pthread_key_create(&key, &cleanup_function) when the first thread is started.

I presume you mean the second thread, or the first started via pthread_create() Every process has one thread at startup. All code that is executed is executed in a thread.

Also, "when" is a bit fiddly. It is cleanest for the initial thread to create the key, and that before launching any other threads. Otherwise, you need to engage additional synchronization to avoid a data race.

I don't want to call pthread_key_delete in the cleanup routine because it will run whenever a thread exits instead of when all threads have exited.

The documentation refers to your "cleanup function" as a destructor , which term I find to be more indicative of the intended purpose: not generic cleanup, but appropriate teardown for thread-specific values associated with the key. You have nevertheless come to the right conclusion, however. The destructor function, if given, should tear down only a value, not the key.

Can I just completely leave out pthread_key_delete ? Will this (having called pthread_key_create without calling pthread_key_delete afterward) cause any memory leak when the program eventually comes to a halt?

That is unspecified, so it is safest to ensure that pthread_key_delete() is called. If all threads using the key are joinable then you can do that after joining them. You could also consider registering an exit handler to do that, but explicitly destroying the key is better style where that can reasonably be performed.

With that said, you will not leak any ordinary memory if you fail to destroy the key, as the system will reclaim all resources belonging to a process when that process exits. The main risk is that some of the resources associated with the key will be more broadly scoped, and that they would leak. Named semaphores and memory-mapped files are examples of such resources, though I have no knowledge of those specific types of resources being associated with TLD keys.

does the key just go into the garbage collector or get destructed once the entire problem ends?

C implementations do not typically implement garbage collection, though there are add-in garbage collector frameworks for C. But as described above, the resources belonging to a process do get released by the system when the process terminates.