executive summary :pthread_create yes (Unix、Linux、Mac OS X) And so on operating system creation thread function . Its function is to create threads ( It's actually determining the entry point to call the thread function ), After the thread is created , Start running related thread functions .
pthread_create The return value of indicates success , return 0; It means that something has gone wrong , Return to indicate -1.
pthread_create How functions create threads
Function prototype declaration :
#include <pthread.h>
int pthread_create(
pthread_t *restrict tidp, // Newly created thread ID The memory unit pointed to .
const pthread_attr_t *restrict attr, // Thread properties , The default is NULL
void *(*start_rtn)(void *), // Newly created thread from start_rtn The address of the function starts running
void *restrict arg // The default is NULL. If the above function requires parameters , Put the parameters in the structure and take the address as arg Pass in .
);
1. The problem of passing parameters
problem :
Avoid passing the changed quantity directly in the passed parameter , Otherwise, the results will be unpredictable .
Even if it's just creating a single thread , Or when the thread does not get the pass parameter , The variable value obtained by the thread has been modified by the main thread .
Usually the solution :
Re apply for a piece of memory , Store the parameters that need to be passed , Let's take this address as arg Pass in .
2. Pay attention to prevent memory leakage when using
By default through pthread_create The thread created by the function is non disjunctive , from pthread_create The second parameter of the function determines , Without separation , When a thread ends , The system resources it occupies are not really released completely , And it doesn't really end .
Only in pthread_join When function returns , This thread will release its own resources .
Or in the case of separating properties , The end of a thread immediately releases the resources it occupies .
If you want to make sure that after the thread is created , Make sure there are no memory leaks , The following methods must be adopted to regulate pthread_create Use :
1. The setup thread is detached( Separation of attributes )
void run() {
return;
}
int main(){
pthread_t thread;
pthread_attr_t attr;
pthread_attr_init( &attr );
pthread_attr_setdetachstate(&attr,1);
pthread_create(&thread, &attr, run, 0); // The second parameter determines the separation property
//......
return 0;
}
however , In blogs :https://blog.csdn.net/qiurisuixiang/article/details/6648213 Commentary , It was mentioned that :
2. Matching use of pthread_join function
pthread_join() Function will always block the calling thread , Until the specified thread terminates . When pthread_join() After returning , An application can reclaim any data storage space associated with a terminated thread .
however , And also notice that , Be sure to use it with a thread created above , This can also play the role of mutual exclusion . Otherwise, multithreading may preempt CPU resources , The result of operation is uncertain .
Niuke, a topic : What is the output of the following program ?( Undetermined )
#include<stdio.h>
#include<string.h>
#include <pthread.h>
void* print1(void* data){
printf("1 ");
}
void* print2(void* data){
printf("2 ");
}
void* print3(void* data){
printf("3 ");
}
int main(void){
pthread_t t,t1,t2;
pthread_create(&t,0,print1,NULL);
pthread_create(&t1,0,print2,NULL);
pthread_create(&t2,0,print3,NULL);
pthread_join(t,NULL);
pthread_join(t1,NULL);
pthread_join(t2,NULL);
printf("\n");
}
analysis :
stay pthread_join() Before ,3 All threads have committed , They may have been executed in random order , Or maybe not , So the results are unpredictable . But this can also play the role of recycling memory ?
// That's in order .
pthread_create(&t, 0, print1, NULL);
pthread_join(t, NULL);
pthread_create(&t1, 0, print2, NULL);
pthread_join(t1, NULL);
pthread_create(&t2, 0, print3, NULL);
pthread_join(t2, NULL);
Add :pthread_join() function
The function prototype :
int pthread_join(
pthread_t tid, // Threads that need to wait , The specified thread must be in the current process , And it can't be a detached thread
void **status // Threads tid The function executed returns the value ( The return value address needs to be valid ), among status It can be for NULL
);
pthread Not linux The default library of the system , Manual link required - Thread library -lpthread
Return value :
Call successfully returned 0.
ESRCH
describe : Not found with the given thread ID The corresponding thread .( If multiple threads wait for the same thread to terminate , All waiting threads will wait until the target thread terminates . Then a wait thread returns successfully . The remaining waiting threads will fail and return ESRCH error )
EDEADLK
describe : There will be a deadlock , Like a thread waiting for itself , Or threads A And thread B Waiting for each other .
EINVAL
describe : With the given thread ID The corresponding thread is the detached thread .