Does the process automatically clean up the resources taken by pthreads upon exit

Question

Assume that I have a code something like this :

void *my_thread(void *data)
{
    while (1) { }
}

void foo_init(struct my_resource *res)
{
    pthread_create(&res->tid, NULL, my_thread, res);

    /* Some init code */
}

void foo_exit(void)
{
    /* Some exit code */
}

The scenario is something like this. When the process gets initialized, the function foo_init() is called with a pointer to my allocated resources(the allocation is done automatically by some other function, which isn't under my control). Within the function I am creating a pthread , which runs in infinite loop.

After a while when the process is about to terminate, the function foo_exit() is called, but this time without the pointer to my resources, and hence I am unable to call pthread_join() , as my tid is contained within my_resource structure.

Now my question is that, whether the resources pertaining to the pthreads are destroyed upon the termination of the process by the OS or not? If yes, how can I make that sure.

Also is it safe to terminate the process without calling pthread_join() ?

Thanks in advance.

Answer 1

If you're talking about allocated memory, yes. When a process exits all virtual memory pages allocated to that process are returned to the system, which will clean up all memory allocated within your process.

Generally the OS is supposed to clean up all resources associated with a process on exit. It will handle closing file handles (which can include sockets and RPC mechanisms), wiping away the stack, and cleaning up kernel resources for the task.

Short answer, if the OS doesn't clean up after a process it is a bug in the OS. But none of us write buggy software right?

Answer 2

All "regular" resources needed by a process are released automatically by the OS when the process terminates (eg memory, sockets, file handles). The most important exception is shared memory but also other resources can be problematic if they're managed not by OS but by other processes.

For example if your process talks to a daemon or to another process like a window manager and allocates resources, whether or not those are released in case the process terminates without releasing them depends on the implementation.

Answer 3

I think the question can be answered another way: pthreads do not own any resources, resources are owned by the process. (A pthread may be the "custodian" of resources, such as memory it has malloc'ed, but it is not the owner.) When the process terminates, any still running pthreads suddenly stop and then the usual process clean-up happens.

POSIX says (for _Exit() ):

• Threads terminated by a call to _Exit() or _exit() shall not invoke their cancellation cleanup handlers or per-thread data destructors.

For exit() POSIX specifies a little more clean-up -- in particular running all atexit() things and flushing streams and such -- before proceeding as if by _Exit() . Note that this does not invoke any pthread cancellation cleanup for any pthread -- the system cannot tell what state any pthread is in, and cannot be sure of being able to pthread_cancel() all pthreads, so does the only thing it can do, which is to stop them all dead.

I can recommend the Single UNIX® Specification (POSIX) -- like any standard, it's not an easy read, but worth getting to know.