Shulou(Shulou.com)06/01 Report--

Based on how the linuxthread 2.0.1 thread carries on the source code analysis join.c, aiming at this question, this article introduces the corresponding analysis and the solution in detail, hoping to help more partners who want to solve this problem to find a more simple and feasible method.

There are three functions in the join.c file, so let's take a look at them one by one.

1 pthread_exit

/ / Thread exit

Void pthread_exit (void * retval)

{

/ / get the structure of the current thread

Pthread_t self = thread_self ()

Pthread_t joining

Struct pthread_request request

/ * Reset the cancellation flag to avoid looping if the cleanup handlers

Contain cancellation points * /

/ / set to 0 to avoid judging the cancel state in other functions, and then adjust the pthread_exit function

Self- > p_canceled = 0

/ * Call cleanup functions and destroy the thread-specific data * /

/ / execute the function of the clean node

_ _ pthread_perform_cleanup ()

/ / iterate through the pthread_keys array to destroy the specifics data in the thread

_ _ pthread_destroy_specifics ()

/ * Store return value * /

/ / add lock

Acquire (& self- > p_spinlock)

/ / exit value, which can be returned to other threads in join

Self- > p_retval = retval

/ * Say that we've terminated * /

/ / terminated

Self- > p_terminated = 1

/ * See if someone is joining on us * /

/ / determine if any other thread is waiting for the thread to exit

Joining = self- > p_joining

Release (& self- > p_spinlock)

/ * Restart joining thread if any * /

/ / wake him up

If (joining! = NULL) restart (joining)

/ * If this is the initial thread, block until all threads have terminated.

If another thread calls exit, we'll be terminated from our signal

Handler. , /

/ / if the main thread exits, notify the manage thread, and if it is a normal thread, directly execute exit exit

If (self = = _ _ pthread_main_thread & & _ _ pthread_manager_request > = 0) {

Request.req_thread = self

Request.req_kind = REQ_MAIN_THREAD_EXIT

/ / write to the pipeline

_ _ libc_write (_ _ pthread_manager_request, (char *) & request, sizeof (request))

/ / suspend and wait for wake up. Wake up the main thread only after all the child threads exit, and then the main thread also exits. See the _ _ pthread_manager function of manager.c

Suspend (self)

}

/ * Exit the process (but don't flush stdio streams, and don't run

Atexit functions). , /

/ / for thread exit, see operating system implementation

_ exit (0)

}

2 pthread_join

/ / the thread that calls the function waits for the thread to finish.

Int pthread_join (pthread_t th, void * * thread_return)

{

Volatile pthread_t self = thread_self ()

Struct pthread_request request

/ / you can't wait for yourself to finish, otherwise you will be deadlocked, that is, you can't finish it.

If (th = = self) return EDEADLK

Acquire (& th- > p_spinlock)

/ * If detached or already joined, error * /

/ / the th thread is already in detach state, that is, it is not joinable, or it has been passed by jion

If (th- > p_detached | | th- > p_joining! = NULL) {

Release (& th- > p_spinlock)

Return EINVAL

}

/ * If not terminated yet, suspend ourselves. , /

/ / if the thread of join is still running, you need to wait

If (! Th- > p_terminated) {

/ / record who is in join th

Th- > p_joining = self

Release (& th- > p_spinlock)

/ / wait for wake up. The self thread will be awakened only when th exits. See pthread_exit 's restart.

Suspend_with_cancellation (self)

Acquire (& th- > p_spinlock)

/ * This is a cancellation point * /

/ / cancel the point

If (self- > p_canceled & & self- > p_cancelstate = = PTHREAD_CANCEL_ENABLE) {

Th- > p_joining = NULL

Release (& th- > p_spinlock)

Pthread_exit (PTHREAD_CANCELED)

}

}

/ * Get return value * /

/ / the thread has ended. Set the return value of the thread.

If (thread_return! = NULL) * thread_return = th- > p_retval

Release (& th- > p_spinlock)

/ * Send notification to thread manager * /

/ / at the writing end of the pipe, the join thread has exited, notifying the manage thread to reclaim the resources of the exiting thread, as shown in REQ_FREE processing.

If (_ _ pthread_manager_request > = 0) {

/ / send a notification to the manager thread that the th thread has ended, and self is the sender

Request.req_thread = self

Request.req_kind = REQ_FREE

Request.req_args.free.thread = th

/ / write to the pipeline

_ _ libc_write (_ _ pthread_manager_request

(char *) & request, sizeof (request))

}

Return 0

}

3 pthread_detach

Int pthread_detach (pthread_t th)

{

Int terminated

Struct pthread_request request

Acquire (& th- > p_spinlock)

/ * If already detached, error * /

/ / detach has passed

If (th- > p_detached) {

Release (& th- > p_spinlock)

Return EINVAL

}

/ * If already joining, don't do anything. , /

/ / there is a thread join this thread, cannot detach

If (th- > p_joining! = NULL) {

Release (& th- > p_spinlock)

Return 0

}

/ * Mark as detached * /

/ / the tag has been detach

Th- > p_detached = 1

Terminated = th- > p_terminated

Release (& th- > p_spinlock)

/ * If already terminated, notify thread manager to reclaim resources * /

/ / Thread has exited. When detach, notify manager,__pthread_manager_request that it is the pipe writer.

If (terminated & & _ _ pthread_manager_request > = 0) {

Request.req_thread = thread_self ()

Request.req_kind = REQ_FREE

Request.req_args.free.thread = th

_ _ libc_write (_ _ pthread_manager_request

(char *) & request, sizeof (request))

}

Return 0

}

This is the answer to the question about how to analyze the source code of join.c based on Linux thread 2.0.1 thread. I hope the above content can be of some help to you. If you still have a lot of doubts to be solved, you can follow the industry information channel for more related knowledge.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.