python线程id

发布时间: 2023-11-26 18:13:31

1. python多进程和多线程的区别

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

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

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

线程的特点：

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

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

进程与线程区别：

同一个进程中的线程共享同一内存空间，但进程之间的内存空间是独立的。
同一个进程中的所有线程的数据是共享的，但进程之间的数据是独立的。
对主线程的修改可能会影响其他线程的行为，但是父进程的修改（除了删除以外）不会影响其他子进程。
线程是一个上下文的执行指令，而进程则是与运算相关的一簇资源。
同一个进程的线程之间可以直接通信，但是进程之间的交流需要借助中间代理来实现。
创建新的线程很容易，但是创建新的进程需要对父进程做一次复制。
一个线程可以操作同一进程的其他线程，但是进程只能操作其子进程。
线程启动速度快，进程启动速度慢（但是两者运行速度没有可比性）。

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

2. Python中threading的join和setDaemon的区别及用法

Python多线程编程时经常会用到join()和setDaemon()方法，基本用法如下：
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
setDaemon，将该线程标记为守护线程或用户线程

1、join ()方法：主线程A中，创建了子线程B，并且在主线程A中调用了B.join()，那么，主线程A会在调用的地方等待，直到子线程B完成操作后，才可以接着往下执行，那么在调用这个线程时可以使用被调用线程的join方法。
原型：join([timeout])，里面的参数时可选的，代表线程运行的最大时间，即如果超过这个时间，不管这个此线程有没有执行完毕都会被回收，然后主线程或函数都会接着执行的。

import threadingimport time class MyThread(threading.Thread): def __init__(self, id): threading.Thread.__init__(self) self.id = id def run(self): x = 0 time.sleep(10) print(self.id) print('线程结束：'+str(time.time())) if __name__ == "__main__": t1 = MyThread(999) print('线程开始：'+str(time.time())) t1.start() print('主线程打印开始：'+str(time.time())) for i in range(5): print(i) time.sleep(2) print('主线程打印结束：' + str(time.time()))

线程开始：1497534590.2784667
主线程打印开始：1497534590.2794669
0
1
2
3
4
主线程打印结束：1497534592.279581
999
线程结束：1497534600.2800388
从打印结果可知，线程t1 start后，主线程并没有等线程t1运行结束后再执行，而是在线程执行的同时，执行了后面的语句。

现在，把join()方法加到启动线程后面(其他代码不变)

import threadingimport time class MyThread(threading.Thread): def __init__(self, id): threading.Thread.__init__(self) self.id = id def run(self): x = 0 time.sleep(10) print(self.id) print('线程结束：'+str(time.time())) if __name__ == "__main__": t1 = MyThread(999) print('线程开始：'+str(time.time())) t1.start() t1.join() print('主线程打印开始：'+str(time.time())) for i in range(5): print(i) time.sleep(2) print('主线程打印结束：' + str(time.time()))

线程开始：1497535176.5019968
999
线程结束：1497535186.5025687
主线程打印开始：1497535186.5025687
0
1
2
3
4
主线程打印结束：1497535188.5026832
线程t1 start后，主线程停在了join()方法处，等子线程t1结束后，主线程继续执行join后面的语句。

2、setDaemon()方法。主线程A中，创建了子线程B，并且在主线程A中调用了B.setDaemon()，这个的意思是，把主线程A设置为守护线程，这时候，要是主线程A执行结束了，就不管子线程B是否完成，一并和主线程A退出.这就是setDaemon方法的含义，这基本和join是相反的。此外，还有个要特别注意的：必须在start() 方法调用之前设置。import threading
import time class MyThread(threading.Thread): def __init__(self, id): threading.Thread.__init__(self) self.id = id def run(self): x = 0 time.sleep(10) print(self.id) print("This is：" + self.getName()) # 获取线程名称 print('线程结束：' + str(time.time())) if __name__ == "__main__": t1 = MyThread(999) print('线程开始：'+str(time.time())) t1.setDaemon(True) t1.start() print('主线程打印开始：'+str(time.time())) for i in range(5): print(i) time.sleep(2) print('主线程打印结束：' + str(time.time()))

线程开始：1497536678.8509264
主线程打印开始：1497536678.8509264
0
1
2
3
4
主线程打印结束：1497536680.8510408

t1.setDaemon(True)的操作，将子线程设置为了守护线程。根据setDaemon()方法的含义，父线程打印内容后便结束了，不管子线程是否执行完毕了。
如果在线程启动前没有加t1.setDaemon(True)，输出结果为：
线程开始：1497536865.3215919
主线程打印开始：1497536865.3215919
0
1
2
3
4
主线程打印结束：1497536867.3217063
999
This is：Thread-1
线程结束：1497536875.3221638
程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程就分兵两路，分别运行，那么当主线程完成想退出时，会检验子线程是否完成，如果子线程未完成，则主线程会等待子线程完成后再退出；
有时我们需要的是，子线程运行完，才继续运行主线程，这时就可以用join方法（在线程启动后面）；
但是有时候我们需要的是，只要主线程完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法（在线程启动前面）。

3. 小白都看懂了，Python 中的线程和进程精讲，建议收藏

众所周知，CPU是计算机的核心，它承担了所有的计算任务。而操作系统是计算机的管理者，是一个大管家，它负责任务的调度，资源的分配和管理，统领整个计算机硬件。应用程序是具有某种功能的程序，程序运行与操作系统之上

在很早的时候计算机并没有线程这个概念，但是随着时代的发展，只用进程来处理程序出现很多的不足。如当一个进程堵塞时，整个程序会停止在堵塞处，并且如果频繁的切换进程，会浪费系统资源。所以线程出现了

线程是能拥有资源和独立运行的最小单位，也是程序执行的最小单位。一个进程可以拥有多个线程，而且属于同一个进程的多个线程间会共享该进行的资源

① 200 多本 Python 电子书（和经典的书籍）应该有

② Python标准库资料（最全中文版）

③ 项目源码（四五十个有趣且可靠的练手项目及源码）

④ Python基础入门、爬虫、网络开发、大数据分析方面的视频（适合小白学习）

⑤ Python学习路线图（告别不入流的学习）
私信我01即可获取大量Python学习资源

进程时一个具有一定功能的程序在一个数据集上的一次动态执行过程。进程由程序，数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时需要的数据和工作区；程序控制块（PCB）包含程序的描述信息和控制信息，是进程存在的唯一标志

在Python中，通过两个标准库 thread 和 Threading 提供对线程的支持, threading 对 thread 进行了封装。 threading 模块中提供了 Thread , Lock , RLOCK , Condition 等组件

在Python中线程和进程的使用就是通过 Thread 这个类。这个类在我们的 thread 和 threading 模块中。我们一般通过 threading 导入

默认情况下，只要在解释器中，如果没有报错，则说明线程可用

守护模式：

现在我们程序代码中，有多个线程，并且在这个几个线程中都会去操作同一部分内容，那么如何实现这些数据的共享呢？

这时，可以使用 threading库里面的锁对象 Lock 去保护

Lock 对象的acquire方法是申请锁

每个线程在操作共享数据对象之前，都应该申请获取操作权，也就是调用该共享数据对象对应的锁对象的acquire方法，如果线程A 执行了 acquire() 方法，别的线程B 已经申请到了这个锁，并且还没有释放，那么线程A的代码就在此处等待线程B 释放锁，不去执行后面的代码。

直到线程B 执行了锁的 release 方法释放了这个锁，线程A 才可以获取这个锁，就可以执行下面的代码了

如：

到在使用多线程时，如果数据出现和自己预期不符的问题，就可以考虑是否是共享的数据被调用覆盖的问题

使用 threading 库里面的锁对象 Lock 去保护

Python中的多进程是通过multiprocessing包来实现的，和多线程的threading.Thread差不多，它可以利用multiprocessing.Process对象来创建一个进程对象。这个进程对象的方法和线程对象的方法差不多也有start(), run(), join()等方法，其中有一个方法不同Thread线程对象中的守护线程方法是setDeamon，而Process进程对象的守护进程是通过设置daemon属性来完成的

守护模式：

其使用方法和线程的那个 Lock 使用方法类似

Manager的作用是提供多进程共享的全局变量，Manager()方法会返回一个对象，该对象控制着一个服务进程，该进程中保存的对象运行其他进程使用代理进行操作

语法：

线程池的基类是 concurrent.futures 模块中的 Executor ， Executor 提供了两个子类，即 ThreadPoolExecutor 和 ProcessPoolExecutor ，其中 ThreadPoolExecutor 用于创建线程池，而 ProcessPoolExecutor 用于创建进程池

如果使用线程池/进程池来管理并发编程，那么只要将相应的 task 函数提交给线程池/进程池，剩下的事情就由线程池/进程池来搞定

Exectuor 提供了如下常用方法：

程序将 task 函数提交（submit）给线程池后，submit 方法会返回一个 Future 对象，Future 类主要用于获取线程任务函数的返回值。由于线程任务会在新线程中以异步方式执行，因此，线程执行的函数相当于一个“将来完成”的任务，所以 Python 使用 Future 来代表

Future 提供了如下方法：

使用线程池来执行线程任务的步骤如下：

最佳线程数目 = （（线程等待时间+线程CPU时间）/线程CPU时间）* CPU数目

也可以低于 CPU 核心数

使用线程池来执行线程任务的步骤如下：

关于进程的开启代码一定要放在 if __name__ == '__main__': 代码之下，不能放到函数中或其他地方

开启进程的技巧

开启进程的数量最好低于最大 CPU 核心数

4. Python多线程总结

在实际处理数据时，因系统内存有限，我们不可能一次把所有数据都导出进行操作，所以需要批量导出依次操作。为了加快运行，我们会采用多线程的方法进行数据处理， 以下为我总结的多线程批量处理数据的模板：

主要分为三大部分：

共分4部分对多线程的内容进行总结。

先为大家介绍线程的相关概念:

在飞车程序中，如果没有多线程，我们就不能一边听歌一边玩飞车，听歌与玩游戏不能并行；在使用多线程后，我们就可以在玩游戏的同时听背景音乐。在这个例子中启动飞车程序就是一个进程，玩游戏和听音乐是两个线程。

Python 提供了 threading 模块来实现多线程:

因为新建线程系统需要分配资源、终止线程系统需要回收资源，所以如果可以重用线程，则可以减去新建/终止的开销以提升性能。同时，使用线程池的语法比自己新建线程执行线程更加简洁。

Python 为我们提供了 ThreadPoolExecutor 来实现线程池，此线程池默认子线程守护。它的适应场景为突发性大量请求或需要大量线程完成任务，但实际任务处理时间较短。

其中 max_workers 为线程池中的线程个数，常用的遍历方法有 map 和 submit+as_completed 。根据业务场景的不同，若我们需要输出结果按遍历顺序返回，我们就用 map 方法，若想谁先完成就返回谁，我们就用 submit+as_complete 方法。

我们把一个时间段内只允许一个线程使用的资源称为临界资源，对临界资源的访问，必须互斥的进行。互斥，也称间接制约关系。线程互斥指当一个线程访问某临界资源时，另一个想要访问该临界资源的线程必须等待。当前访问临界资源的线程访问结束，释放该资源之后，另一个线程才能去访问临界资源。锁的功能就是实现线程互斥。

我把线程互斥比作厕所包间上大号的过程，因为包间里只有一个坑，所以只允许一个人进行大号。当第一个人要上厕所时，会将门上上锁，这时如果第二个人也想大号，那就必须等第一个人上完，将锁解开后才能进行，在这期间第二个人就只能在门外等着。这个过程与代码中使用锁的原理如出一辙，这里的坑就是临界资源。 Python 的 threading 模块引入了锁。 threading 模块提供了 Lock 类，它有如下方法加锁和释放锁：

我们会发现这个程序只会打印“第一道锁”，而且程序既没有终止，也没有继续运行。这是因为 Lock 锁在同一线程内第一次加锁之后还没有释放时，就进行了第二次 acquire 请求，导致无法执行 release ，所以锁永远无法释放，这就是死锁。如果我们使用 RLock 就能正常运行，不会发生死锁的状态。

在主线程中定义 Lock 锁，然后上锁，再创建一个子线程t 运行 main 函数释放锁，结果正常输出，说明主线程上的锁，可由子线程解锁。

如果把上面的锁改为 RLock 则报错。在实际中设计程序时，我们会将每个功能分别封装成一个函数，每个函数中都可能会有临界区域，所以就需要用到 RLock 。

一句话总结就是 Lock 不能套娃， RLock 可以套娃； Lock 可以由其他线程中的锁进行操作， RLock 只能由本线程进行操作。

5. python之多线程

进程的概念：以一个整体的形式暴露给操作系统管理，里面包含各种资源的调用。对各种资源管理的集合就可以称为进程。
线程的概念：是操作系统能够进行运算调度的最小单位。本质上就是一串指令的集合。

进程和线程的区别：
1、线程共享内存空间，进程有独立的内存空间。
2、线程启动速度快，进程启动速度慢。注意：二者的运行速度是无法比较的。
3、线程是执行的指令集，进程是资源的集合
4、两个子进程之间数据不共享，完全独立。同一个进程下的线程共享同一份数据。
5、创建新的线程很简单，创建新的进程需要对他的父进程进行一次克隆。
6、一个线程可以操作（控制）同一进程里的其他线程，但是进程只能操作子进程
7、同一个进程的线程可以直接交流，两个进程想要通信，必须通过一个中间代理来实现。
8、对于线程的修改，可能会影响到其他线程的行为。但是对于父进程的修改不会影响到子进程。

第一个程序，使用循环来创建线程，但是这个程序中一共有51个线程，我们创建了50个线程，但是还有一个程序本身的线程，是主线程。这51个线程是并行的。注意：这个程序中是主线程启动了子线程。

相比上个程序，这个程序多了一步计算时间，但是我们观察结果会发现，程序显示的执行时间只有0.007秒，这是因为最后一个print函数它存在于主线程，而整个程序主线程和所有子线程是并行的，那么可想而知，在子线程还没有执行完毕的时候print函数就已经执行了，总的来说，这个时间只是执行了一个线程也就是主线程所用的时间。

接下来这个程序，吸取了上面这个程序的缺点，创建了一个列表，把所有的线程实例都存进去，然后使用一个for循环依次对线程实例调用join方法，这样就可以使得主线程等待所创建的所有子线程执行完毕才能往下走。 注意实验结果：和两个线程的结果都是两秒多一点

注意观察实验结果，并没有执行打印task has done，并且程序执行时间极其短。
这是因为在主线程启动子线程前把子线程设置为守护线程。
只要主线程执行完毕，不管子线程是否执行完毕，就结束。但是会等待非守护线程执行完毕
主线程退出，守护线程全部强制退出。皇帝死了，仆人也跟着殉葬
应用的场景： socket-server

注意：gil只是为了减低程序开发复杂度。但是在2.几的版本上，需要加用户态的锁（gil的缺陷）而在3点几的版本上，加锁不加锁都一样。

下面这个程序是一个典型的生产者消费者模型。
生产者消费者模型是经典的在开发架构中使用的模型
运维中的集群就是生产者消费者模型，生活中很多都是

那么，多线程的使用场景是什么？
python中的多线程实质上是对上下文的不断切换，可以说是假的多线程。而我们知道，io操作不占用cpu，计算占用cpu，那么python的多线程适合io操作密集的任务，比如socket-server，那么cpu密集型的任务，python怎么处理？python可以折中的利用计算机的多核：启动八个进程，每个进程有一个线程。这样就可以利用多进程解决多核问题。

6. python里如何终止线程比如线程里调用os.system('adb logcat')这个是不会停止的

如果直接终止线程不清楚，要不曲线下，新开启一个进程，再得到这个进程id，然后干掉这个进程
import
multiprocessing
def
NewProcess():
global
id
id=os.getpid()
os.system('adb
logcat')
NP=multiporcess.Process(target=one
function,args=())
NP.start()
os.kill(id,9)

7. 一文带你读懂Python线程

Python线程

进程有很多优点，它提供了多道编程，可以提高计算机CPU的利用率。既然进程这么优秀，为什么还要线程呢？其实，仔细观察就会发现进程还是有很多缺陷的。

主要体现在一下几个方面：

进程只能在一个时间做一个任务，如果想同时做两个任务或多个任务，就必须开启多个进程去完成多个任务。

进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行。

每个进程都有自己的独立空间，所以多进程的创建，销毁相比于多线程更加耗时，也更加占用系统资源。

进程是资源分配的最小单位，线程是CPU调度的最小单位，每一个进程中至少有一个线程。

线程与进程的区别

可以归纳为以下4点：

1）地址空间：进程间相互独立的每个进程都有自己独立的内存空间，也就是说一个进程内的数据在另一个进程是不可见的。但同一进程中的各线程间数据是共享的。

2）通信：由于每个进程有自己独立的内存空间，所以进程间通信需要IPC，而进程内的数据对于多个线程来说是共享的，每个线程都可以访问，所以为了保证数据的一致性，需要使用锁。

3）调度和切换：线程上下文切换比进程上下文切换要快得多。

4）在多线程操作系统中，进程不是一个可执行的实体，它主要的功能是向操作系统申请一块内存空间，然后在内存空间中开线程来执行任务，相当于一个容器，容器中的线程才是真正的执行体。一个进程可以包含多个线程，而一个线程是不能包含进程的。因为进程是系统分配资源的最小单位，所以线程不能向操作系统申请自己的空间，但一个线程内可以包含多个线程。

python线程id

与python线程id相关的资讯