1、验证多线程是否共享全局变量
import threading
import time
#1.定义一个全局变量
g_num = 100
#2.定义2个函数,用他们来充当线程要执行的代码
def task1():
global g_num
for i in range(3):
g_num += 1
print("在task1中, g_num = %d---" % g_num)
def task2():
global g_num
print(" 在task2中, g_num =%d---" % g_num)
#3.创建线程对象
t1 = threading.Thread(target=task1)
t1.start()
#延时一会,保证t1线程中的事情做完,否则不能确定到底该运行哪一个线程,保证让task1里面的任务先执行完毕。
time.sleep(1)
t2 = threading.Thread(target=task2)
t2.start()
#4.调用start()创建线程,让线程开始运行
运行结果如下;
---线程创建之前g_num is 100---
----in work1, g_num is 103---
----in work2, g_num is 103---
小结:
- 如果一个程序有多个线程,每个线程可以单独执行自己的任务。
- 如果多个线程之间需要数据共享,最简单的方式,通过全局变量来实现。
- 一个线程修改全局变量,另外一个线程从全局变量中获取数据。
- 缺点:通过全局变量可以解决多个线程之间共享数据的问题。但是,如果使用数据不恰当,会导致数据错乱。例如有3个线程,其中第1、2个修改全局变量,而第3个线程获取了全局变量的值,可能会出现第一个线程刚刚将数据存放到了全局变量中,本意是想让第3个线程获取它的数据,因为操作系统的调度原因导致了线程3没有被调度,而第2个线程被调度了,恰巧第2个线程也对全局变量进行了修改,当第3个线程去读取数据的时候,读取到的是第2个线程的数据,而不是在第1个线程的数据。
2、列表当作实参传递到线程中
import threading
import time
def work1(nums):
nums.append(44)
print("----in work1---", nums)
def work2(nums):
#延时一会,保证t1线程中的事情做完
time.sleep(1)
print("----in work2---", nums)
g_nums = [11,22,33]
t1 = threading.Thread(target=work1, args=(g_nums,))
t1.start()
t2 = threading.Thread(target=work2, args=(g_nums,))
t2.start()
运行结果如下:
----in work1--- [11, 22, 33, 44]
----in work2--- [11, 22, 33, 44]
3、多线程开发可能遇到的问题
假设两个线程t1和t2都要对全局变量g_num(默认是0)进行加1运算,t1和t2都各对g_num加10次,g_num的最终的结果应该为20。
但是由于是多线程同时操作,有可能出现下面情况:
- 在g_num=0时,t1取得g_num=0。此时系统把t1调度为”sleeping”状态,把t2转换为”running”状态,t2也获得g_num=0
- 然后t2对得到的值进行加1并赋给g_num,使得g_num=1
- 然后系统又把t2调度为”sleeping”,把t1转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。
- 这样导致虽然t1和t2都对g_num加1,但结果仍然是g_num=1
3.1、每个线程+100
import threading
import time
g_num = 0
def work1(num):
global g_num
for i in range(num):
g_num += 1
print("----in work1, g_num is %d---"%g_num)
def work2(num):
global g_num
for i in range(num):
g_num += 1
print("----in work2, g_num is %d---"%g_num)
print("---线程创建之前g_num is %d---"%g_num)
t1 = threading.Thread(target=work1, args=(100,))
t1.start()
t2 = threading.Thread(target=work2, args=(100,))
t2.start()
while len(threading.enumerate()) != 1:
time.sleep(1)
print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)
运行结果:
---线程创建之前g_num is 0---
----in work1, g_num is 100---
----in work2, g_num is 200---
2个线程对同一个全局变量操作之后的最终结果是:200
3.2、每个线程+一百万,放大更能看出问题
import threading
import time
g_num = 0
def work1(num):
global g_num
for i in range(num):
g_num += 1
print("----in work1, g_num is %d---"%g_num)
def work2(num):
global g_num
for i in range(num):
g_num += 1
print("----in work2, g_num is %d---"%g_num)
print("---线程创建之前g_num is %d---"%g_num)
t1 = threading.Thread(target=work1, args=(1000000,))
t1.start()
t2 = threading.Thread(target=work2, args=(1000000,))
t2.start()
while len(threading.enumerate()) != 1:
time.sleep(1)
print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)
运行结果:
---线程创建之前g_num is 0--- ----in work1, g_num is 1088005--- ----in work2, g_num is 1286202--- 2个线程对同一个全局变量操作之后的最终结果是:1286202
4、互斥锁
4.1、作用:
互斥锁为资源引入一个状态:锁定/非锁定
某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性。
4.2、使用互斥锁
import threading
# 创建锁
mutex = threading.Lock()
# 锁定
mutex.acquire()
# 释放
mutex.release()
小结:
- 如果这个锁之前是没有上锁的,那么acquire不会堵塞(堵塞:理解为程序卡在这里等待某个条件满足)
- 如果在调用acquire对这个锁上锁之前 它已经被 其他线程上了锁,那么此时acquire会堵塞,直到这个锁被解锁为止
4.3、使用互斥锁解决资源竞争问题:
2个线程对同一个全局变量各加100万次
import threading
import time
g_num = 0
def test1(num):
global g_num
for i in range(num):
mutex.acquire() # 上锁
g_num += 1
mutex.release() # 解锁
print("---test1---g_num=%d"%g_num)
def test2(num):
global g_num
for i in range(num):
mutex.acquire() # 上锁
g_num += 1
mutex.release() # 解锁
print("---test2---g_num=%d"%g_num)
# 创建一个互斥锁
# 默认是未上锁的状态
mutex = threading.Lock()
# 创建2个线程,让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()
p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()
# 等待计算完成
while len(threading.enumerate()) != 1:
time.sleep(1)
print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)
运行结果:
---test1---g_num=1586698
---test2---g_num=2000000
2个线程对同一个全局变量操作之后的最终结果是:2000000
4.4、上锁解锁过程
每一个锁都有状态,当一个线程调用锁的acquire()方法获得锁时,锁就进入“locked”状态。
每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁,该线程就会变为“blocked”状态,称为“阻塞”,直到拥有锁的线程调用锁的release()方法释放锁之后,即这个锁进入“unlocked”状态后,才能获取到这个锁
线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁,并使得该线程进入运行(running)状态。
小结:
锁的好处:
- 确保了某段关键代码同时只能由一个线程从头到尾完整地执行
锁的坏处:
- 阻止了多线程并发执行,包含锁的某段代码实际上只能以单线程模式执行,效率就大大地下降了
- 由于可以存在多个锁,不同的线程持有不同的锁,并试图获取对方持有的锁时,可能会造成死锁。
5、进程
进程:一个程序运行起来后,代码+用到的资源 称之为进程,它是操作系统分配资源的基本单元。
5.1、可以实现多任务
在python中使用使用进程实现多任务的方式有3种:
- 创建Process对象
- 基础Process类,创建自己的对象,实现run翻番
- 使用进程池
5.2、创建进程方式-1
multiprocessing模块是跨平台版本的多进程模块,提供了一个Process类来创建一个进程对象,这个对象可以理解为是一个独立的进程,可以执行另外的事情
from multiprocessing import Process
import time
def test():
"""子进程单独执行的代码"""
while True:
print('---test---')
time.sleep(1)
if __name__ == '__main__':
p=Process(target=test)
p.start()
# 主进程单独执行的代码
while True:
print('---main---')
time.sleep(1)
运行结果
---main---
---test---
---main---
---test---
---main---
---test---
小结:
- 通过额外创建一个进程,可以实现多任务
- 使用进程实现多任务的流程:
- 创建一个Process对象,且在创建时通过target指定一个函数的引用
- 当调用start时,会真正的创建一个子进程
5.3、进程 PID
from multiprocessing import Process
import os
import time
def run_proc():
"""子进程要执行的代码"""
print('子进程运行中,pid=%d...' % os.getpid()) # os.getpid获取当前进程的进程号
print('子进程将要结束...')
if __name__ == '__main__':
print('父进程pid: %d' % os.getpid()) # os.getpid获取当前进程的进程号
p = Process(target=run_proc)
p.start()
运行结果:
父进程pid: 17292
子进程运行中,pid=10440...
子进程将要结束...
5.4、Process创建的实例对象所使用的方法
- start():启动子进程实例(创建子进程)
- is_alive():判断子进程是否还在活着
- join([timeout]):是否等待子进程执行结束,或等待多少秒
- terminate():不管任务是否完成,立即终止子进程
5.5、创建进程方式-2
from multiprocessing import Process
import time
class MyNewProcess(Process):
def run(self):
while True:
print('---1---')
time.sleep(1)
if __name__ == '__mian__':
p = MyNewProcess()
# 调用p.start()方法,p会先去父类中寻找start(),然后在Process的start方法中调用run方法
p.start()
while True:
print('---Main---')
time.sleep(1)
小结:
- 此种创建多进程的流程
- 自定义一个类,继承Process类
- 实现run方法
- 通过自定义的类,创建实例对象
- 调用实例对象的start方法
- 对比
- 自定义继承Process类的方式比 直接创建Process对象 要稍微复杂一些,但是可以用来实现更多较为复杂逻辑的功能
- 建议
- 如果想快速的实现一个进程,功能较为简单的话,可以直接创建Process的实例对象
- 如果想实现一个功能较为完整、逻辑较为复杂的进程,可以自定义继承Process类 来实现。
6、创建进程对象时传递参数
为了在创建进程对象时,能够将不同的数据传递给进程,可以给Process类的__init__
方法传递参数
from multiprocessing import Process
import os
from time import sleep
def run_proc(name, age, **kwargs):
for i in range(10):
print('子进程运行中,name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
print(kwargs)
sleep(0.2)
if __name__=='__main__':
p = Process(target=run_proc, args=('test',18), kwargs={"m":20})
p.start()
sleep(1) # 1秒中之后,立即结束子进程
p.terminate()
p.join()
运行结果:
子进程运行中,name= test,age=18 ,pid=3528...
{'m': 20}
子进程运行中,name= test,age=18 ,pid=3528...
{'m': 20}
子进程运行中,name= test,age=18 ,pid=3528...
{'m': 20}
子进程运行中,name= test,age=18 ,pid=3528...
{'m': 20}
子进程运行中,name= test,age=18 ,pid=3528...
{'m': 20}
小结:
- 调用Process类创建进程对象时
- target指明 创建进程后,进程指定的代码是哪个函数
- args、kwargs用来给 那个函数指明传递的实参
- args:元组
- kwargs:字典
7.进程不共享全局变量
from multiprocessing import Process
import os
import time
nums = [11, 22]
def work1():
"""子进程要执行的代码"""
print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
for i in range(3):
nums.append(i)
time.sleep(1)
print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
def work2():
"""子进程要执行的代码"""
print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))
if __name__ == '__main__':
p1 = Process(target=work1)
p1.start()
time.sleep(2)
p2 = Process(target=work2)
p2.start()
运行结果:
in process1 pid=5644 ,nums=[11, 22]
in process1 pid=5644 ,nums=[11, 22, 0]
in process1 pid=5644 ,nums=[11, 22, 0, 1]
in process2 pid=6532 ,nums=[11, 22]
in process1 pid=5644 ,nums=[11, 22, 0, 1, 2]
8、进程间通信--Queue
进程间是相互独立的,数据不共享,但有时需要数据共享,就需要进程间通信(IPC)
例如之前学习的网络编程udp、tcp,其实就是一种实现多进程间数据共享的方式,只是它通过套接字(socket)实现了不同电脑上的进程间通信
如果在一台电脑上不同进程间通信,就可以用其它的方式实现(知道即可,不需要深入研究,研究操作系统时才需要深入研究它们):
-
文件(一个进程写入到文件,一个进程从文件中读取)
-
共享内存
8.1、Queue的使用
from multiprocessing import Queue
q = Queue(3) # 初始化一个Queue对象,最多可接收三条put消息
q.put("消息1")
q.put("消息2")
print(q.full()) # False
q.put("消息3")
print(q.full()) # True
# 因为消息列队已满,所以会导致下面的try都会抛出异常,
# 第一个try会等待2秒后再抛出异常
# 第二个Try会立刻抛出异常
try:
q.put("消息4", True, 2)
except:
print("消息列队已满,现有消息数量:%s" % q.qsize())
try:
q.put_nowait("消息4")
except:
print("消息列队已满,现有消息数量:%s" % q.qsize())
# 推荐的方式,先判断消息列队是否已满,再写入
if not q.full():
q.put_nowait("消息4")
# 读取消息时,先判断消息列队是否为空,再读取
if not q.empty():
for i in range(q.qsize()):
print(q.get_nowait())
运行结果:
False
True
消息列队已满,现有消息数量:3
消息列队已满,现有消息数量:3
消息1
消息2
消息3
小结:
- 使用
Queue()
时,若括号中没有指定最大可接收的消息数量,或数量为负值,那么就代表可接受的消息数量没有上限(直到内存的尽头) - Queue的几个方法功能说明:
Queue.qsize()
:返回当前队列包含的消息数量Queue.empty()
:如果队列为空,返回True
,反之False
Queue.full()
:如果队列满了,返回True,反之FalseQueue.get([block[, timeout]])
:获取队列中的一条消息,然后将其从列队中移除,block默认值为True
- 如果block使用默认值,且没有设置timeout(单位秒),消息列队如果为空,此时程序将被阻塞(停在读取状态),直到从消息列队读到消息为止,如果设置了timeout,则会等待timeout秒,若还没读取到任何消息,则抛出
Queue.Empty
异常 - 如果block值为
False
,消息列队如果为空,则会立刻抛出Queue.Empty
异常
- 如果block使用默认值,且没有设置timeout(单位秒),消息列队如果为空,此时程序将被阻塞(停在读取状态),直到从消息列队读到消息为止,如果设置了timeout,则会等待timeout秒,若还没读取到任何消息,则抛出
Queue.get_nowait()
:相当Queue.get(False)
Queue.put(item,[block[, timeout]])
:将item消息写入队列,block默认值为True
- 如果block使用默认值,且没有设置timeout(单位秒),消息列队如果已经没有空间可写入,此时程序将被阻塞(停在写入状态),直到从消息列队腾出空间为止,如果设置了timeout,则会等待timeout秒,若还没空间,则抛出
Queue.Full
异常 - 如果block值为
False
,消息列队如果没有空间可写入,则会立刻抛出Queue.Full
异常
- 如果block使用默认值,且没有设置timeout(单位秒),消息列队如果已经没有空间可写入,此时程序将被阻塞(停在写入状态),直到从消息列队腾出空间为止,如果设置了timeout,则会等待timeout秒,若还没空间,则抛出
Queue.put_nowait(item)
:相当Queue.put(item, False)
8.2、 Queue实例
from multiprocessing import Process, Queue
import time, random
# 写数据进程执行的代码:
def task1(q):
for value in ['A', 'B', 'C']:
print('Put %s to queue...' % value)
q.put(value)
time.sleep(random.random())
# 读数据进程执行的代码:
def task2(q):
while True:
if not q.empty():
value = q.get(True)
print('Get %s from queue.' % value)
time.sleep(random.random())
else:
break
if __name__=='__main__':
# 父进程创建Queue,并传给各个子进程:
q = Queue()
write_p = Process(target=task1, args=(q,))
read_p = Process(target=task2, args=(q,))
# 启动子进程pw,写入:
write_p.start()
# 等待pw结束:
write_p.join()
# 启动子进程pr,读取:
read_p.start()
read_p.join()
# pr进程里是死循环,无法等待其结束,只能强行终止:
print('')
print('所有数据都写入并且读完')
运行结果:
Put A to queue...
Put B to queue...
Put C to queue...
Get A from queue.
Get B from queue.
Get C from queue.
所有数据都写入并且读完
9、创建进程方式-3--->进程池
当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。
初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会用之前的进程来执行新的任务。
from multiprocessing import Pool
import os
import random
import time
def worker(num):
for i in range(5):
print('===pid=%d==num=%d='%(os.getpid(),num))
time.sleep(1)
# 3表示进程池中最多有三个进程一起执行
pool=Pool(3)
for i in range(10):
print('---%d---'%i)
# 向进程中添加任务
# 注意:如果添加的任务数量超过了进程池中进程的个数的话,那么就不会接着往进程池中添加,
# 如果还没有执行的话,他会等待前面的进程结束,然后在往
# 进程池中添加新进程
pool.apply_async(worker,(i,))
pool.close() # 关闭进程池
pool.join() # 主进程在这里等待,只有子进程全部结束之后,在会开启主线程
小结:
apply_async(func[, args[, kwds]])
:使用非阻塞方式调用func(并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给func的关键字参数列表;close()
:关闭Pool,使其不再接受新的任务;terminate()
:不管任务是否完成,立即终止;join()
:主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用。
10、进程池中的Queue
# -*- coding:utf-8 -*-
# 修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time,random
def reader(q):
print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
for i in range(q.qsize()):
print("reader从Queue获取到消息:%s" % q.get(True))
def writer(q):
print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
for i in "itcast":
q.put(i)
if __name__=="__main__":
print("(%s) start" % os.getpid())
q = Manager().Queue() # 使用Manager中的Queue
po = Pool()
po.apply_async(writer, (q,))
time.sleep(1) # 先让上面的任务向Queue存入数据,然后再让下面的任务开始从中取数据
po.apply_async(reader, (q,))
po.close()
po.join()
print("(%s) End" % os.getpid())
运行结果:
(8784) start
writer启动(11136),父进程为(8784)
reader启动(11136),父进程为(8784)
reader从Queue获取到消息:i
reader从Queue获取到消息:t
reader从Queue获取到消息:c
reader从Queue获取到消息:a
reader从Queue获取到消息:s
reader从Queue获取到消息:t
(8784) End
11、文件夹copy器-->多进程版
import multiprocessing
import os
import time
import random
def copy_file(queue, file_name,source_folder_name, dest_folder_name):
"""copy文件到指定的路径"""
f_read = open(source_folder_name + "/" + file_name, "rb")
f_write = open(dest_folder_name + "/" + file_name, "wb")
while True:
time.sleep(random.random())
content = f_read.read(1024)
if content:
f_write.write(content)
else:
break
f_read.close()
f_write.close()
# 发送已经拷贝完毕的文件名字
queue.put(file_name)
def main():
# 获取要复制的文件夹
source_folder_name = input("请输入要复制文件夹名字:")
# 整理目标文件夹
dest_folder_name = source_folder_name + "[副本]"
# 创建目标文件夹
try:
os.mkdir(dest_folder_name)
except:
pass # 如果文件夹已经存在,那么创建会失败
# 获取这个文件夹中所有的普通文件名
file_names = os.listdir(source_folder_name)
# 创建Queue
queue = multiprocessing.Manager().Queue()
# 创建进程池
pool = multiprocessing.Pool(3)
for file_name in file_names:
# 向进程池中添加任务
pool.apply_async(copy_file, args=(queue, file_name, source_folder_name, dest_folder_name))
# 主进程显示进度
pool.close()
all_file_num = len(file_names)
while True:
file_name = queue.get()
if file_name in file_names:
file_names.remove(file_name)
copy_rate = (all_file_num-len(file_names))*100/all_file_num
print("\r%.2f...(%s)" % (copy_rate, file_name) + " "*50, end="")
if copy_rate >= 100:
break
print()
if __name__ == "__main__":
main()
小结:
进程线程对比:
-
进程是系统进行资源分配和调度的一个独立单位.
-
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
- 一个程序至少有一个进程,一个进程至少有一个线程.
- 线程的划分尺度小于进程(资源比进程少),使得多线程程序的并发性高。
- 进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。
- 线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源的管理和保护;而进程正相反。