python thread 怎么区分主线程

在Python语言中Python线程可以从这里开始与主线程对GIL的竞争，在t_bootstrap中，申请完了GIL，也就是说子线程也就获得了GIL，使其始终保存着活动线程的状态对象。

当PyEval_AcquireThread结束之后，子线程也就获得了GIL，并且做好了一切执行的准备。接下来子线程通过PyEval_ CallObjectWithKeywords，将最终调用我们已经非常熟悉的PyEval_EvalFrameEx。

也就是Python的字节码执行引擎。传递进PyEval_CallObjectWithKeywords的boot->func是一PyFunctionObject对象，正是therad1py中定义的threadProc编译后的结果。在PyEval_CallObjectWithKeywords结束之后，子线程将释放GIL，并完成销毁线程的所有扫尾工作，到了这里，子线程就结束了。

从t_bootstrap的代码看上去，似乎子线程会一直执行，直到子线程的所有计算都完成，才会通过PyThreadState_DeleteCurrent释放GIL。如此一来，那主线程岂非一直都会处于等待GIL的状态？如果真是这样，那Python线程显然就不可能支持多线程机制了。

实际上在PyEval_EvalFrameEx中，图15-2中显示的Python内部维护的那个模拟时钟中断会不断地激活线程的调度机制，在子线程和主线程之间不断地进行切换。从而真正实现多线程机制，当然，这一点我们将在后面详细剖析。现在我们感兴趣的是子线程在PyEval_AcquireThreade中到底做了什么。

到这里，了解了PyEval_AcquireThread，似乎创建线程的机制都清晰了。但实际上，有一个非常重要的机制——线程状态保护机制——隐藏在了一个毫不起眼的地方：PyThreadState_New。

[threadmodulec] 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]：创建bootstate结构 boot = PyMem_NEW(struct bootstate, 1); boot->interp = PyThreadState_GET()->interp; boot->funcfunc = func; boot->argsargs = args; boot->keywkeyw = keyw; //[2]：初始化多线程环境 PyEval_InitThreads(); / Start the interpreter's thread-awareness / //[3]：创建线程 ident = PyThread_start_new_thread(t_bootstrap, (void) boot); return PyInt_FromLong(ident); [threadc] / 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_nth] long PyThread_start_new_thread(void (func)(void ), void arg) { unsigned long rv; callobj obj; objid = -1; / guilty until proved innocent / objfunc = func; objarg = arg; objdone = CreateSemaphore(NULL, 0, 1, NULL); rv = _beginthread(bootstrap, _pythread_stacksize, &obj); / use default stack size / if (rv == (unsigned long)-1) { //创建raw thread失败 objid = -1; } else { WaitForSingleObject(objdone, INFINITE); } CloseHandle((HANDLE)objdone); return objid; }

这个机制对于理解Python线程的创建和维护是非常关键的。要剖析线程状态的保护机制，我们首先需要回顾一下线程状态。在Python中，每一个Python线程都会有一个线程状态对象与之关联。

在线程状态对象中，记录了每一个线程所独有的一些信息。实际上，在剖析Python的初始化过程时，我们曾经见过这个对象。每一个线程对应的线程状态对象都保存着这个线程当前的PyFrameObject对象，线程的id这样一些信息。有时候，线程是需要访问这些信息的。

比如考虑一个最简单的情形，在某种情况下，每个线程都需要访问线程状态对象中所保存的thread_id信息，显然，线程A获得的应该是A的thread_id，线程B亦然。倘若线程A获得的是B的thread_id，那就坏菜了。这就意味着Python线程内部必须有一套机制，这套机制与 *** 作系统管理进程的机制非常类似。

我们知道，在 *** 作系统从进程A切换到进程B时，首先会保存进程A的上下文环境，再进行切换；当从进程B切换回进程A时，又会恢复进程A的上下文环境，这样就保证了进程A始终是在属于自己的上下文环境中运行。

这里的线程状态对象就等同于进程的上下文，Python同样会有一套存储、恢复线程状态对象的机制。同时，在Python内部，维护着一个全局变量：PyThreadState _PyThread- State_Current。

当前活动线程所对应的线程状态对象就保存在这个变量里，当Python调度线程时，会将被激活的线程所对应的线程状态对象赋给_PyThreadState_Current，使其始终保存着活动线程的状态对象。

这就引出了这样的一个问题：Python如何在调度进程时，获得被激活线程对应的状态对象？Python内部会通过一个单向链表来管理所有的Python线程的状态对象，当需要寻找一个线程对应的状态对象时。

到这里，我们要聊一下线程通信的内容；

首先，我们抛开语言不谈，先看看比较基础的东西，线程间通信的方式；其实也就是哪几种（我这里说的，是我的所谓的知道的。。。）事件，消息队列，信号量，条件变量（锁算不算？我只是认为是同步的一种）；所以我们也就是要把这些掌握了，因为各有各的好处嘛；

条件变量我放到了上面的线程同步里面讲了，我总感觉这算是同步的一种，没有很多具体信息的沟通；同时吧，我认为条件变量比较重要，因为这种可以应用于线程池的 *** 作上；所以比较重要；这里，抛开条件变量不谈，我们看看其他的东西；

1、消息队列：

queue 模块下提供了几个阻塞队列，这些队列主要用于实现线程通信。在 queue 模块下主要提供了三个类，分别代表三种队列，它们的主要区别就在于进队列、出队列的不同。

关于这三个队列类的简单介绍如下：

queueQueue(maxsize=0)：代表 FIFO（先进先出）的常规队列，maxsize 可以限制队列的大小。如果队列的大小达到队列的上限，就会加锁，再次加入元素时就会被阻塞，直到队列中的元素被消费。如果将 maxsize 设置为 0 或负数，则该队列的大小就是无限制的。

queueLifoQueue(maxsize=0)：代表 LIFO（后进先出）的队列，与 Queue 的区别就是出队列的顺序不同。

PriorityQueue(maxsize=0)：代表优先级队列，优先级最小的元素先出队列。

这三个队列类的属性和方法基本相同， 它们都提供了如下属性和方法：

Queueqsize()：返回队列的实际大小，也就是该队列中包含几个元素。

Queueempty()：判断队列是否为空。

Queuefull()：判断队列是否已满。

Queueput(item, block=True, timeout=None)：向队列中放入元素。如果队列己满，且 block 参数为 True（阻塞），当前线程被阻塞，timeout 指定阻塞时间，如果将 timeout 设置为 None，则代表一直阻塞，直到该队列的元素被消费；如果队列己满，且 block 参数为 False（不阻塞），则直接引发 queueFULL 异常。

Queueput_nowait(item)：向队列中放入元素，不阻塞。相当于在上一个方法中将 block 参数设置为 False。

Queueget(item, block=True, timeout=None)：从队列中取出元素（消费元素）。如果队列已满，且 block 参数为 True（阻塞），当前线程被阻塞，timeout 指定阻塞时间，如果将 timeout 设置为 None，则代表一直阻塞，直到有元素被放入队列中； 如果队列己空，且 block 参数为 False（不阻塞），则直接引发 queueEMPTY 异常。

Queueget_nowait(item)：从队列中取出元素，不阻塞。相当于在上一个方法中将 block 参数设置为 False。

其实我们想想，这个队列，是python进行封装的，那么我们可以用在线程间的通信；同时也是可以用做一个数据结构；先进先出就是队列，后进先出就是栈；我们用这个栈写个十进制转二进制的例子：

没毛病，可以正常的打印；其中需要注意的就是，maxsize在初始化的时候如果是0或者是个负数的话，那么就会是不限制大小；

那么其实我们想想，我们如果用做线程通信的话，我们两个线程，可以把队列设置为1的大小，如果是1对多，比如是创建者和消费者的关系，我们完全可以作为消息队列，比如说创建者一直在创建一些东西，然后放入到消息队列里面，然后供消费着使用；就是一个很好的例子；所以，其实说是消息队列，也就是队列，没差；

=====================================================================

下面来看一下事件

Event 是一种非常简单的线程通信机制，一个线程发出一个 Event，另一个线程可通过该 Event 被触发。

Event 本身管理一个内部旗标，程序可以通过 Event 的 set() 方法将该旗标设置为 True，也可以调用 clear() 方法将该旗标设置为 False。程序可以调用 wait() 方法来阻塞当前线程，直到 Event 的内部旗标被设置为 True。

Event 提供了如下方法：

is_set()：该方法返回 Event 的内部旗标是否为True。

set()：该方法将会把 Event 的内部旗标设置为 True，并唤醒所有处于等待状态的线程。

clear()：该方法将 Event 的内部旗标设置为 False，通常接下来会调用 wait() 方法来阻塞当前线程。

wait(timeout=None)：该方法会阻塞当前线程。

这里我想解释一下；其实对于事件来说，事件可以看成和条件变量是一样的，只是我们说说不一样的地方；

1、对于事件来说，一旦触发了事件，也就是说，一旦set为true了，那么就会一直为true，需要clear调内部的标志，才能继续wait；但是conditon不是，他是一次性的唤醒其他线程；

2、conditon自己带锁；事件呢？不是的；没有自己的锁；比如说有一个存钱的线程，有一个是取钱的线程；那么存钱的线程要存钱；需要怎么办呢？1、发现银行没有钱了（is_set判断）；2、锁住银行；3、存钱；4、释放银行；5、唤醒事件；对于取钱的人；1、判断是否有钱；2、被唤醒了，然后锁住银行；3、开始取钱；4、清理告诉存钱的人，我没钱了（clear）；5、释放锁；6、等着钱存进去；

其实说白了，就是记住一点；这个旗标需要自己clear就对了

写个例子，怕以后忘了怎么用；

其实时间和信号量比较像；但是信号量不用自己清除标志位；但是事件是需要的；

1 使用ossystem函数运行其他程序

2 使用ShellExecute函数运行其他程序

3 使用CreateProcess函数运行其他程序

4 使用ctypes调用kernel32dll中的函数

1 使用ossystem函数运行其他程序

os模块中的system()函数可以方便地运行其他程序或者脚本。其函数原型如下所示。

ossystem(command) 其参数含义如下所示。

command 要执行的命令，相当于在Windows的cmd窗口中输入的命令。如果要向程序或者脚本传递参数，可以使用空格分隔程序及多个参数。

以下实例实现通过ossystem()函数打开系统的记事本程序。

>>> import os # 使用ossystem()函数打开记事本程序 >>> ossystem('notepad') 0 # 关闭记事本后的返回值 # 向记事本传递参数，打开pythontxt文件 >>> ossystem('notepad pythontxt')

>>> import os # 使用ossystem()函数打开记事本程序 >>> ossystem('notepad') 0 # 关闭记事本后的返回值 # 向记事本传递参数，打开pythontxt文件 >>> ossystem('notepad pythontxt')

2 使用ShellExecute函数运行其他程序

除了使用os模块中的ossystem()函数以外，还可以使用win32api模块中的ShellExecute()函数。其函数如下所示。

ShellExecute(hwnd, op , file , params , dir , bShow )

其参数含义如下所示。

hwnd：父窗口的句柄，如果没有父窗口，则为0。

op：要进行的 *** 作，为“open”、“print”或者为空。

file：要运行的程序，或者打开的脚本。

arams：要向程序传递的参数，如果打开的为文件，则为空。

dir：程序初始化的目录。

Show：是否显示窗口。

以下实例使用ShellExecute函数运行其他程序。

>>> import win32api # 打开记事本程序，在后台运行，即显示记事本程序的窗口 >>> win32apiShellExecute(0, 'open', 'notepadexe', '','',0)

# 打开记事本程序，在前台运行 >>> win32apiShellExecute(0, 'open', 'notepadexe', '','',1)

# 向记事本传递参数，打开pythontxt >>> win32apiShellExecute(0, 'open', 'notepadexe', 'pythontxt','',1)

# 在默认浏览器中打开>

进程是程序（软件，应用）的一个执行实例，每个运行中的程序，可以同时创建多个进程，但至少要有一个。每个进程都提供执行程序所需的所有资源，都有一个虚拟的地址空间、可执行的代码、 *** 作系统的接口、安全的上下文（记录启动该进程的用户和权限等等）、唯一的进程ID、环境变量、优先级类、最小和最大的工作空间（内存空间）。进程可以包含线程，并且每个进程必须有至少一个线程。每个进程启动时都会最先产生一个线程，即主线程，然后主线程会再创建其他的子线程。

线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不独立拥有系统资源，但它可与同属一个进程的其它线程共享该进程所拥有的全部资源。每一个应用程序都至少有一个进程和一个线程。在单个程序中同时运行多个线程完成不同的被划分成一块一块的工作，称为多线程。

举个例子，某公司要生产一种产品，于是在生产基地建设了很多厂房，每个厂房内又有多条流水生产线。所有厂房配合将整个产品生产出来，单个厂房内的流水线负责生产所属厂房的产品部件，每个厂房都拥有自己的材料库，厂房内的生产线共享这些材料。公司要实现生产必须拥有至少一个厂房一条生产线。换成计算机的概念，那么这家公司就是应用程序，厂房就是应用程序的进程，生产线就是某个进程的一个线程。

线程的特点：

线程是一个execution context（执行上下文），即一个cpu执行时所需要的一串指令。假设你正在读一本书，没有读完，你想休息一下，但是你想在回来时继续先前的进度。有一个方法就是记下页数、行数与字数这三个数值，这些数值就是execution context。如果你的室友在你休息的时候，使用相同的方法读这本书。你和她只需要这三个数字记下来就可以在交替的时间共同阅读这本书了。

线程的工作方式与此类似。CPU会给你一个在同一时间能够做多个运算的幻觉，实际上它在每个运算上只花了极少的时间，本质上CPU同一时刻只能干一件事，所谓的多线程和并发处理只是假象。CPU能这样做是因为它有每个任务的execution context，就像你能够和你朋友共享同一本书一样。

进程与线程区别：

同一个进程中的线程共享同一内存空间，但进程之间的内存空间是独立的。

同一个进程中的所有线程的数据是共享的，但进程之间的数据是独立的。

对主线程的修改可能会影响其他线程的行为，但是父进程的修改（除了删除以外）不会影响其他子进程。

线程是一个上下文的执行指令，而进程则是与运算相关的一簇资源。

同一个进程的线程之间可以直接通信，但是进程之间的交流需要借助中间代理来实现。

创建新的线程很容易，但是创建新的进程需要对父进程做一次复制。

一个线程可以 *** 作同一进程的其他线程，但是进程只能 *** 作其子进程。

线程启动速度快，进程启动速度慢（但是两者运行速度没有可比性）。

由于现代cpu已经进入多核时代，并且主频也相对以往大幅提升，多线程和多进程编程已经成为主流。Python全面支持多线程和多进程编程，同时还支持协程。

以前python的threading 模块写多线程也用的挺多的，但是一般就是同时执行多个函数

通过上面的函数我们不难发现一个问题，我们无法获取到每一个线程执行之后的返回值

主要是通过重写Thread里面的run()方法,改变了多线程的执行方式，通过get_result得到函数运行的返回值

一般在子线程/进程里打印信息，来判断不同线程/进程运行到了指定位置。

类的方式实例化后，可以调用is_alive()方法判断是否在运行。

下面这里有个例子可以试试，有注释，会python的话应该直接就能看懂。

>

以上就是关于python thread 怎么区分主线程全部的内容，包括:python thread 怎么区分主线程、python基础（21）-线程通信、怎么调用编写好的python程序等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！