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

👉[[CSDN大礼包：《python兼职资源&全套学习资料》免费分享]]（安全链接，放心点击）

3、 进程

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

4、 区别

1. 一个进程由一个或者多个线程组成，线程是一个进程中代码的不同执行路线
2. 切换进程需要的资源比切换线程的要多的多
3. 进程之间相互独立，而同一个进程下的线程共享程序的内存空间（如代码段，数据集，堆栈等）。某进程内的线程在其他进程不可见。换言之，线程共享同一片内存空间，而进程各有独立的内存空间

5、 使用

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

二、 多线程使用

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

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

from threading import Thread

1、 常用方法

Thread.run(self)  # 线程启动时运行的方法，由该方法调用 target 参数所指定的函数
Thread.start(self)  # 启动线程，start 方法就是去调用 run 方法
Thread.terminate(self)  # 强制终止线程
Thread.join(self, timeout)  # 阻塞调用，主线程进行等待
Thread.setDaemon(self, daemonic)  # 将子线程设置为守护线程
Thread.getName(self, name)  # 获取线程名称
Thread.setName(self, name)  # 设置线程名称

2、 常用参数

参数	说明
target	表示调用对象，即子线程要执行的任务
name	子线程的名称
args	传入 target 函数中的位置参数，是一个元组，参数后必须添加逗号

3、 多线程的应用

3.1 重写线程法

import time, queue, threading


class MyThread(threading.Thread):

    def __init__(self):
        super().__init__()
        self.daemon = True  # 开启守护模式
        self.queue = queue.Queue(3)  # 开启队列对象，存储三个任务
        self.start()  # 实例化的时候直接启动线程，不需要手动启动线程

    def run(self) -> None:  # run方法线程自带的方法,内置方法，在线程运行时会自动调用
        while True:  # 不断处理任务
            func, args, kwargs = self.queue.get()
            func(*args, **kwargs)  # 调用函数执行任务 元组不定长记得一定要拆包
            self.queue.task_done()  # 解决一个任务就让计数器减一，避免阻塞

    # 生产者模型
    def submit_tasks(self, func, args=(), kwargs={}):  # func为要执行的任务，加入不定长参数使用（默认使用默认参数）
        self.queue.put((func, args, kwargs))  # 提交任务

    # 重写join方法
    def join(self) -> None:
        self.queue.join()  # 查看队列计时器是否为0 任务为空 为空关闭队列
        
        
def f2(*args, **kwargs):
    time.sleep(2)
    print("任务2完成", args, kwargs)

# 实例化线程对象
mt = MyThread()
# 提交任务
mt.submit_tasks(f2, args=("aa", "aasd"), kwargs={"a": 2, "s": 3})

# 让主线程等待子线程结束再结束
mt.join()

守护模式：

• 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束

3.2 直接调用法

def f2(i):
    time.sleep(2)
    print("任务2完成", i)

lis = []
for i in range(5):
    t = Thread(target=f2, args=(i,))
    t.start()  # 启动 5 个线程
    lis.append(t)

for i in lis:
    i.join()  # 线程等待

4、 线程间数据的共享

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

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

Lock 对象的acquire方法 是申请锁

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

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

如：

import threading

var = 1
# 添加互斥锁，并且拿到锁
lock = threading.Lock()

# 定义两个线程要用做的任务
def func1():
    global var  # 声明全局变量
    for i in range(1000000):
        lock.acquire()  # 操作前上锁
        var += i
        lock.release()  # 操作完后释放锁
        
def func2():
    global var  # 声明全局变量
    for i in range(1000000):       
		lock.acquire()  # 操作前上锁    
        var -= i
        lock.release()  # 操作完后释放锁
        
# 创建2个线程
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t1.start()
t2.start()
t1.join()
t2.join()
print(var)

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

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

三、 多进程使用

1、 简介

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

2、 应用

2.1 重写进程法

import time
from multiprocessing import Process


class MyProcess(Process):  # 继承Process类
    def __init__(self, target, args=(), kwargs={}):
        super(MyProcess, self).__init__()
        self.daemon = True  # 开启守护进程
        self.target = target
        self.args = args
        self.kwargs = kwargs
        self.start()  # 自动开启进程

    def run(self):
        self.target(*self.args, **self.kwargs)


def fun(*args, **kwargs):
    print(time.time())
    print(args[0])


if __name__ == '__main__':
    lis = []
    for i in range(5):
        p = MyProcess(fun, args=(1, ))
        lis.append(p)
    for i in lis:
        i.join()  # 让进程等待

守护模式：

• 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束

2.2 直接调用法

import time
from multiprocessing import  Process

def fun(*args, **kwargs):
    print(time.time())
    print(args[0])

if __name__ == '__main__':
    lis = []
    for i in range(5):
        p = Process(target=fun, args=(1, ))
        lis.append(p)
    for i in lis:
        i.join()  # 让进程等待

3、 进程之间的数据共享

3.1 Lock 方法

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

3.2 Manager 方法

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

Manager支持的类型有：list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value和Array

语法：

做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。

别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。

我先来介绍一下这些东西怎么用，文末抱走。

---

（1）Python所有方向的学习路线（新版）

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。

（2）Python学习视频

包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

（3）100多个练手项目

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

（4）200多本电子书

这些年我也收藏了很多电子书，大概200多本，有时候带实体书不方便的话，我就会去打开电子书看看，书籍可不一定比视频教程差，尤其是权威的技术书籍。

基本上主流的和经典的都有，这里我就不放图了，版权问题，个人看看是没有问题的。

（5）Python知识点汇总

知识点汇总有点像学习路线，但与学习路线不同的点就在于，知识点汇总更为细致，里面包含了对具体知识点的简单说明，而我们的学习路线则更为抽象和简单，只是为了方便大家只是某个领域你应该学习哪些技术栈。

（6）其他资料

还有其他的一些东西，比如说我自己出的Python入门图文类教程，没有电脑的时候用手机也可以学习知识，学会了理论之后再去敲代码实践验证，还有Python中文版的库资料、MySQL和HTML标签大全等等，这些都是可以送给粉丝们的东西。

这些都不是什么非常值钱的东西，但对于没有资源或者资源不是很好的学习者来说确实很不错，你要是用得到的话都可以直接抱走，关注过我的人都知道，这些都是可以拿到的。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里无偿获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！