How to establish a main Python thread?

In Python, If you create a program, it is a process, including a thread, which is the main thread, but to improve the resource usage efficiency and system efficiency, I hope you can learn the information you want again.

From this we can see that when a thread starts to wait for GIL, its owned will be increased by 1. Obviously, we can guess that when a thread finally releases GIL, it will definitely subtract 1 from the GIL owned so that after all the threads that need GIL are finally released, owned will change to-1 again, meaning GIL will become available again.

To clearly display this point, let's take a look at the inverse operation of PyThread_aquire_lock, pyThread_release_lock every thread that changes from running to waiting state will call it before being suspended to release the possession of GIL.

 
 

  
  
[thread_nt.h]  
  
  
 
  
  
PNRMUTEX AllocNonRecursiveMutex(void)  
  
  
 
  
  
{  
  
  
 
  
  
    PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;  
  
  
 
  
  
    if(mutex && !InitializeNonRecursiveMutex(mutex)) {  
  
  
 
  
  
            free(mutex);  
  
  
 
  
  
            Mutex = NULL;  
  
  
 
  
  
    }  
  
  
 
  
  
    return mutex ;  
  
  
 
  
  
}  
  
  
 
  
  
BOOL InitializeNonRecursiveMutex(PNRMUTEX mutex)  
  
  
 
  
  
{  
  
  
 
  
  
    ……  
  
  
 
  
  
    mutex->owned = -1 ;  /* No threads have entered NonRecursiveMutex */  
  
  
 
  
  
    mutex->thread_id = 0 ;  
  
  
 
  
  
    mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;  
  
  
 
  
  
    return mutex->hevent != NULL ;  /* TRUE if the mutex is created */  
  
  
 
  
  
}  
 
 

In the end, when a thread releases GIL, it will notify all the threads waiting for the hevent of GIL through SetEvent. Combined with the previous analysis, if there is a thread waiting for the hevent of GIL at this time, then it will be awakened by the operating system.

This is the mechanism that we introduced earlier in Python to delegate the second difficulty of thread scheduling to the operating system. At this time, the thread that calls PyEval_InitThread, that is, the main Python thread, has successfully obtained GIL. Finally, PyThread_get_thread_ident () is called ().

Use the Win32 API: GetCurrent-ThreadId to obtain the id of the current main Python thread and assign it to main_thread. main_thread is a static global variable that stores the thread id of the main Python thread, used to determine whether a thread is a main Python thread.

After the multi-threaded environment is initialized, Python will start to create the native thread of the underlying platform. Taking thread1.py as an example, this native thread will execute the operations defined by threadProc. From now on, to clarify the description, we call the main Python thread, namely thread_PyThread_start_new_thread, to create a new thread named as the main thread, the native thread corresponding to threadProc is called a subthread. Now let's take a look at how a subthread is created.

 
 

  
  
Static PyObject * thread_PyThread_start_new_thread (PyObject * self, PyObject
  
  
 
  
  
* Fargs)
  
  
 
  
  
{
  
  
 
  
  
PyObject * func, * args ,*Keyw=NULL;
  
  
 
  
  
Struct bootstate * boot;
  
  
 
  
  
Long ident;
  
  
 
  
  
PyArg_UnpackTuple (fargs, "start_new_thread", 2, 3, & func, & args, & keyw );
  
  
 
  
  
// [1]: Create a bootstate Structure
  
  
 
  
  
Boot=PyMem_NEW(Struct bootstate, 1 );
  
  
 
  
  
Boot->Interp=PyThreadState_GET()->Interp;
  
  
 
  
  
Boot->FuncFunc= Func;
  
  
 
  
  
Boot->ArgsArgs= Args;
  
  
 
  
  
Boot->KeywKeyw= Keyw;
  
  
 
  
  
// [2]: Initialize the multi-threaded Environment
  
  
 
  
  
PyEval_InitThreads ();/* Start the interpreter's thread-awareness */
  
  
 
  
  
// [3]: Create a thread
  
  
 
  
  
Ident=PyThread_start_new_thread(T_bootstrap, (void *) boot );
  
  
 
  
  
Return PyInt_FromLong (ident );
  
  
 
  
  
[Thread. c]
  
  
 
  
  
/* Support for runtime thread stack size tuning.
  
  
 
  
  
A value of 0 means using the platform's default stack size
  
  
 
  
  
Or the size specified by the THREAD_STACK_SIZE macro .*/
  
  
 
  
  
Static size_t_ Pythread_stacksize=0;
  
  
 
  
  
[Thread_nt.h]
  
  
 
  
  
Long PyThread_start_new_thread (void (* func) (void *), void * arg)
  
  
 
  
  
{
 
 

The main Python thread calls PyThread_start_new_thread to create a subthread. To clearly understand the work of PyThread_start_new_thread, we need to pay special attention to the parameters of this function. From thread _ PyThread_start_new_thread, we can see that func is actually the t_bootstrap function, while arg is the bootstate structure boot created in thread_PyThread_start_new_thread. In boot, stores the thread information defined in the Python program thread1.py.

1. How to embed Python into C ++ applications?
2. In-depth discussion of Ruby and Python syntax comparison
3. Introduction to Python
4. Python Learning Experience: version, IDE selection and encoding solution
5. Analysis of Python GIL and thread security