python：多任务（线程、进程、协程）
一、线程
1、创建线程
# 创建线程 import threading,time def task1(): for i in range(5): print('task1 -- 任务：%s' % i) time.sleep(1) def task2(): for j in range(10): print('task2 -- 任务：%s' % j) time.sleep(1) def main(): # 创建线程 t1 = threading.Thread(target=task1) t2 = threading.Thread(target=task2) # 执行线程 t1.start() t2.start() if __name__ == '__main__': main()
2、查看线程数量
import threading,time # 创建线程 import threading,time def task1(): for i in range(5): print('task1 -- 任务：%s' % i) time.sleep(1) def task2(): for j in range(5): print('task2 -- 任务：%s' % j) time.sleep(1) def main(): # 创建线程 t1 = threading.Thread(target=task1) t2 = threading.Thread(target=task2) # 执行线程 t1.start() t2.start() while True: # 打印当前线程情况 thread_num = len(threading.enumerate()) print("当前线程的数量为：" + str(thread_num)) print('线程详情：') print(threading.enumerate()) if thread_num <= 1: # 当剩下一个线程的情况下（也就是只剩下主线程的情况下，退出） break time.sleep(0.5) if __name__ == '__main__': main()
3、通过继承Thread来创建线程
import threading,time class MyThread(threading.Thread): # 当线程对象调用start()方法的时候，就会自动调用run()方法 def run(self): for i in range(5): # self.name：当前线程的名字 print("I'm " + self.name + ' @ ' + str(i)) time.sleep(1) if __name__ == '__main__': # 创建线程 t1 = MyThread() t2 = MyThread() # 运行线程 t1.start() t2.start()
4、多线程共享全局变量
import threading,time # 定义全局变量 g_num = 100 def task1(): global g_num g_num += 1 print("---- in task1: g_num = %d" % g_num) def task2(): print("---- in task2: g_num = %d" % g_num) def main(): t1 = threading.Thread(target=task1) t2 = threading.Thread(target=task2) t1.start() time.sleep(1) t2.start() time.sleep(1) print("---- in main: g_num = %d" % g_num) if __name__ == '__main__': main()
5、args 参数
import threading,time # 定义全局变量 g_nums = [10, 20] def task1(temp): temp.append(30) print("---- in task1: temp = %s" % str(temp)) def task2(temp): print("---- in task1: temp = %s" % str(temp)) def main(): # args 参数：指定调用函数的时候，传递什么参数过去（args 是元组类型） t1 = threading.Thread(target=task1, args=(g_nums,)) t2 = threading.Thread(target=task2, args=(g_nums,)) t1.start() time.sleep(1) t2.start() time.sleep(1) print("---- in task1: g_nums = %s" % str(g_nums)) if __name__ == '__main__': main()
6、互斥锁解决资源竞争
import threading,time # 定义一个全局变量 g_num = 0 # 创建一个互斥锁 mutex = threading.Lock() def task1(num): global g_num for i in range(num): # 上锁 mutex.acquire() g_num += 1 # 解锁 mutex.release() print('---- in stak1: g_num = %d' % g_num) def task2(num): global g_num for i in range(num): # 上锁 mutex.acquire() g_num += 1 # 解锁 mutex.release() print('---- in stak2: g_num = %d' % g_num) if __name__ == '__main__': # 创建线程 t1 = threading.Thread(target=task1, args=(1000000,)) t2 = threading.Thread(target=task2, args=(1000000,)) # 执行线程 t1.start() t2.start() time.sleep(2) print('---- in main: g_num = %d' % g_num)
7、多线程udp 聊天器
import threading,socket def recv_msg(udp_socket): # 接收数据 while True: recv_data = udp_socket.recvfrom(1024) print('接收到的数据为：%s' % str(recv_data)) def send_msg(udp_socket, dest_ip, dest_port): while True: send_data = input('请输入你要发送的数据：') udp_socket.sendto(send_data.encode('utf-8'), (dest_ip, dest_port)) def main(): # 创建套接字 udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 绑定本地信息 udp_socket.bind(("", 8899)) # 发送数据 dest_ip = "192.168.1.9" dest_port = 8899 # 创建线程 t_recv = threading.Thread(target=recv_msg, args=(udp_socket,)) t_send = threading.Thread(target=send_msg, args=(udp_socket,dest_ip,dest_port)) t_recv.start() t_send.start() if __name__ == '__main__': main()
8、总结
""" 1、什么是线程？ 线程操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 2、线程运行： 通过 t = threading.Thread(target=xxx) 来创建线程。 通过 t.start() 来运行线程。如果没有调用 start() 方法，线程是不会执行的。 3、查看线程数量 可通过 threading.enumerate() 来查看线程数量 4、通过继承Thread来创建线程时，需要重写run()方法。子线程对象在调用start()方法的时候，run()方法就会自动调用。 5、共享全局变量： 1）在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据 2）缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全） 6、传递参数： 创建线程的时候，可以设置参数 args，来指定调用函数的时候，需要传递什么参数。args 的数据类型是元组。 7、互斥锁 某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。 互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。 8、死锁 在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。 避免死锁： 1）程序设计时要尽量避免（银行家算法） 2）添加超时时间等 """
二、进程
1、创建进程
import multiprocessing,time def task1(): while True: print('---- task1 ----') time.sleep(1) def task2(): while True: print('---- task2 ----') time.sleep(1) def main(): # 创建进程对象 p1 = multiprocessing.Process(target=task1) p2 = multiprocessing.Process(target=task2) # 开启进程 p1.start() p2.start() if __name__ == '__main__': main()
2、通过队列完成进程间通信
import multiprocessing def download_data(q): """模拟下载数据""" data = [11, 22, 33, 44] # 向队列中写入数据 for temp in data: print('写入数据到队列：' + str(temp)) q.put(temp) print('------下载器已下载完并写入到队列当中了------') def analysis_data(q): """模拟数据处理""" waiting_data = list() while True: # 从队列中获取数据 temp = q.get() print('从队列中获取数据：' + str(temp)) waiting_data.append(temp) # 判断队列是否为空 if q.empty(): break print('----数据已经分析完毕----') print(waiting_data) def main(): # 创建队列 q = multiprocessing.Queue() # 创建进程 p1 = multiprocessing.Process(target=download_data, args=(q,)) p2 = multiprocessing.Process(target=analysis_data, args=(q,)) # 开启进程 p1.start() p2.start() if __name__ == '__main__': main()
3、进程池
import multiprocessing import os,time,random def worker(index): t_start = time.time() print("{}开始执行，进程号为：{}".format(index, os.getpid())) time.sleep(random.random()*2) t_stop = time.time() print("{} 执行完毕，耗时{}".format(index, round(t_stop-t_start, 2))) def main(): # 定义一个进程池，最大进程数量为 3 po = multiprocessing.Pool(3) for i in range(10): # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,)) # 每次循环将会用空闲出来的子进程去调用目标 po.apply_async(func=worker, args=(i,)) print('-'*10 + 'start' + '-'*10) # 关闭进程池，关闭后po不再接收新的请求 po.close() # 等待po中所有子进程执行完成，必须放在close语句之后 po.join() # 保证进程池中的所有进程都执行完毕后，主进程才会结束 print('-'*10 + 'end' + '-'*10) if __name__ == '__main__': main()
4、多任务拷贝文件夹
import multiprocessing,os # 拷贝文件函数 def copy_file(q, file_name, old_folder_name, new_folder_name): old_file = os.path.join(old_folder_name, file_name) new_file = os.path.join(new_folder_name, file_name) with open(old_file, 'rb') as f: while True: # 最多一次取出1024个字节 content = f.read(1024) if content: with open(new_file, 'ab') as f2: f2.write(content) else: break # 如果拷贝完了文件，那么就放入队列中，表示文件已拷贝完成 q.put(file_name) def main(): # 1、获取用户要拷贝的文件夹名称 old_folder_name = input("请输入你要拷贝的文件夹名称：") # 2、创建一个新的文件夹 new_folder_name = "[复制]" + old_folder_name; try: os.mkdir(new_folder_name) except FileExistsError: pass # 3、获取文件夹中所有的文件名称 file_names = os.listdir(old_folder_name) # 4、创建进程池 po = multiprocessing.Pool(5) # 5、创建进程池队列，通过队列来计算进度（进程间通信） q = multiprocessing.Manager().Queue() # 6、向进程池中添加复制文件的任务 for file_name in file_names: po.apply_async(func=copy_file, args=(q, file_name, old_folder_name, new_folder_name)) po.close() # po.join() # 7、获取队列中的内容，计算已经完成拷贝的文件数量 all_file_num = len(file_names) copy_file_num = 0 while True: file_name = q.get() copy_file_num += 1 print("\r当前拷贝文件夹的进度为：%.2f %%"%(copy_file_num*100/all_file_num), end='') if copy_file_num >= all_file_num: print() break print('Done.') if __name__ == '__main__': main()
总结：
""" 1、什么是进程 程序：例如xxx.py这是程序，是一个静态的 进程：一个程序运行起来后，代码+用到的资源 称之为进程，它是操作系统分配资源的基本单元。 不仅可以通过线程完成多任务，进程也是可以的 2、进程的状态： 就绪、执行、等待 3、如何创建 需使用multiprocessing模块来创建，创建的时候，和线程一样，需要指定要执行的任务是什么，例如： p1 = multiprocessing.Process(target=task1) 4、进程间如何通信？ 进程间可通过队列Queue 来进行通信。 5、进程池 当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程。 但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。 6、进程和线程的对比 进程，能够完成多任务，比如 在一台电脑上能够同时运行多个QQ 线程，能够完成多任务，比如 一个QQ中的多个聊天窗口 进程是系统进行资源分配和调度的一个独立单位。 线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。 线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。 区别： 1）一个程序至少有一个进程,一个进程至少有一个线程。 2）线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高 3）进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率 4）线线程不能够独立执行，必须依存在进程中 5）线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。 """
三、协程
1、迭代器
""" 迭代是访问集合元素的一种方式。 迭代器是一个可以记住遍历的位置的对象。 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。 总结： 1、如果想要一个对象成为 一个可迭代的对象，即可以使用for循环，那么必须实现 __iter__ 方法 2、要构造一个迭代器，就必须实现 __iter__ 方法和 __next__ 方法 3、迭代器抛出 StopIteration 异常，for 循环就会自动停止 """ from collections.abc import Iterable,Iterator import time class Classmate(object): def __init__(self): self.names = list() self.current_index = 0 def add(self, name): self.names.append(name) def __iter__(self): # 如果想要一个对象成为 一个可迭代的对象，即可以使用for循环，那么必须实现 __iter__ 方法 return self def __next__(self): # 迭代器：要构造一个迭代器，就必须实现 __iter__ 方法和 __next__ 方法 if self.current_index < len(self.names): result = self.names[self.current_index] self.current_index += 1 return result else: # 抛出 StopIteration 异常，for 循环就会自动停止 raise StopIteration classmate = Classmate() # 判断对象是否可迭代 print('对象是否可迭代：', isinstance(classmate, Iterable)) # 获取对象的迭代器 classmate_iter = iter(classmate) print('对象是否是迭代器：', isinstance(classmate_iter, Iterator)) classmate.add('张三') classmate.add('李四') classmate.add('王五') classmate.add('赵六') for name in classmate: # classmate：可迭代，并且迭代器就是本身 # name：打印name，其实质是调用迭代器的 __next__ 方法 print(name) time.sleep(1)
2、迭代器应用——斐波那契数列
# 斐波那契数列：0,1,1,2,3,5,....,a,b,a+b class Fibonacci(object): def __init__(self, count): self.count = count self.index = 0 self.a = 0 self.b = 1 def __iter__(self): return self def __next__(self): if self.index < self.count: result = self.a self.a, self.b = self.b, self.a + self.b self.index += 1 return result else: raise StopIteration fibo = Fibonacci(10) for num in fibo: print(num)
3、迭代器的其他应用
""" list、tuple 也可接收可迭代的对象 比如：list(a)：先生成一个空的列表，然后根据a获取 a 的迭代器，再通过next方法获取各个值，最后返回列表 """ class Fibonacci(object): def __init__(self, count): self.count = count self.index = 0 self.a = 0 self.b = 1 def __iter__(self): return self def __next__(self): if self.index < self.count: result = self.a self.a, self.b = self.b, self.a + self.b self.index += 1 return result else: raise StopIteration fibo = Fibonacci(10) list1 = list(fibo) print(list1) tuple1 = (1,2,3,4) list2 = list(tuple1) print(list2) list3 = [1,2,3,4] tuple2 = tuple(list3) print(tuple2)
4、生成器——创建方式 1
""" 生成器是一种特殊的迭代器 创建方式一：只要把一个列表生成式的 [ ] 改成 ( ) """ list1 = [x*2 for x in range(10)] print(list1) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] list2 = (x*2 for x in range(10)) print(list2) # <generator object <genexpr> at 0x101bafad0> for num in list2: print(num) # 0 / 2 / 4 / 6 / 8 / 10 / 12 / 14 / 16 / 18
5、生成器——创建方式 2
""" 生成器创建方式二：使用 yield 如果一个函数中有yield 语句，那么这个就不再是一个函数，而是一个生成器。 执行的程序遇到yield： 1）保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起 2）将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用 下次再执行的时候，就会从yield 语句挂起那开始执行，不再是在函数的最开始位置执行。 可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）。 """ # 打印斐波那契数列 def create_fibonacci(count): a, b = 0, 1 index = 0 while index < count: # 如果一个函数中有yield 语句，那么这个就不再是一个函数，而是一个生成器 # 执行的程序遇到yield，则会在 yield 语句中暂停，并且把这个值返回。 # 下次再执行的时候，就会从yield 语句后面开始执行，不再是在函数的最开始位置执行。 yield a a, b = b, a+b index += 1 return "ok." obj = create_fibonacci(10) print(obj) # <generator object create_fibonacci at 0x108ffaa50> print(type(obj)) # <class 'generator'>：类型是生成器，生成器是一个特殊的迭代器，那么，就可以通过for 循环来获取值 for num in obj: print(num) # 0 / 1 / 1 / 2 / 3 / 5 / 8 / 13 / 21 / 34 print('='*40) obj2 = create_fibonacci(2) while True: try: num = next(obj2) print(num) except Exception as ex: # ex.value：获取生成器上的"ok."字符串 print(ex.value) break # print(next(obj)) # print(next(obj)) # print(next(obj)) # print('='*40) # obj2 = create_fibonacci(2) # print(next(obj2)) # print(next(obj2))
6、使用send()方法来唤醒生成器
""" 我们除了可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。 使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。 """ # 打印斐波那契数列 def create_fibonacci(count): a, b = 0, 1 index = 0 while index < count: ret2 = yield a print(">>>ret>>>", ret2) a, b = b, a+b index += 1 obj = create_fibonacci(10) # 第一次运行，执行到 yield 的时候，将 yield 后面的表达式返回，即将 a 返回。 # 所以就打印出：0 ret = next(obj) print(ret) # 0 # 通过 send 方法传递参数来唤醒 yield 时，程序将在上次断点的位置开始执行，即：ret2 = yield a。 # 这个时候，传递过来的参数，将会将 yield a 替换成传递过来的参数 'hello world!'，然后返回给 ret2。 # 所以就接着打印出：>>>ret>>> hello world! # 然后程序会再次循环到 yield，将 yield 后面的表达式返回，即将 a 返回。所以得到的结果是：1 # 所以就打印出：1 ret = obj.send('hello world!') print(ret)
7、使用 yield 实现多任务
""" 了解 """ import time def task1(): while True: print('-'*10 + '1' + '-'*10) time.sleep(0.5) # 使用yield，此时这个函数已经不再是函数，而是一个生成器 yield def task2(): while True: print('-'*15 + '2' + '-'*15) time.sleep(0.5) yield def main(): count = 0 t1 = task1() t2 = task2() while True: count += 1 # 这是一个假的多任务 # 实现了 2 个任务交替执行，也就是并发执行的。 next(t1) next(t2) if count > 5: break if __name__ == '__main__': main()
8、使用 greenlet 实现多任务
""" 了解：greenlet相当于对 yield 进行了封装，不再需要使用 yield 来创建生成器 """ from greenlet import greenlet import time def task1(): while True: print('-'*10 + '1' + '-'*10) # 切换到gr2中运行 gr2.switch() time.sleep(0.5) def task2(): while True: print('-'*15 + '2' + '-'*15) # 切换到gr1中运行 gr1.switch() time.sleep(0.5) gr1 = greenlet(task1) gr2 = greenlet(task2) # 切换到gr1中运行 gr1.switch()
9、使用gevent协程完成多任务
""" gevent 相当于是对 greenlet 再次进行了封装，即：greenlet 对yield 进行了封装，gevent 对 greenlet 进行了封装 """ import gevent,time from gevent import monkey # 1、将程序中耗时的代码，换为 gevent中自己实现的代码 monkey.patch_all() def work(current_name): for i in range(5): print(current_name, i) time.sleep(0.5) # 2.等待gevent.joinall这个方法里面的所有协程列表都执行完毕，程序才会到 joinall后面的方法 gevent.joinall([ # 创建协程 gevent.spawn(work, 'work1'), gevent.spawn(work, 'work2'), ]) print('Done.')
10、案例：通过gevent实现图片下载器
import gevent from gevent import monkey import uuid, hashlib # 1、将程序中耗时的代码，换为 gevent中自己实现的代码 monkey.patch_all() # import requests需放在key.patch_all()之后，不然会有警告！ import requests # 不重复名称的文件名 def get_unique_str(): uuid_str = str(uuid.uuid4()) md5 = hashlib.md5() md5.update(uuid_str.encode('utf-8')) return md5.hexdigest() # 下载图片 def download_image(image_url): print('准备请求图片：' + image_url) # 图片名称 imagename = get_unique_str() + "." + image_url.split('.')[-1] res = requests.get(image_url) if res.status_code == 200: content = res.content # 保存图片 with open('./images/' + imagename, 'wb') as f: f.write(content) print('图片已下载到本地：' + imagename) else: print('图片请求失败：' + image_url) def main(): imgurls = [ "https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3865738611,3013226268&fm=26&gp=0.jpg", "https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=3057356668,282499874&fm=26&gp=0.jpg" ] tasks = [] for imgur in imgurls: # 添加协程 tasks.append(gevent.spawn(download_image, imgur)) # 执行任务 gevent.joinall(tasks) print('Done.') if __name__ == '__main__': main()
11、案例：爬取百度图片
from gevent import monkey # 将程序中耗时的代码，换为 gevent中自己实现的代码 monkey.patch_all() from gevent.queue import Queue import gevent import requests import re import uuid, hashlib import os # 图片列表队列 works = Queue() def get_unique_str(): """不重复名称的文件名""" uuid_str = str(uuid.uuid4()) md5 = hashlib.md5() md5.update(uuid_str.encode('utf-8')) return md5.hexdigest() def download_image(): """下载图片""" while not works.empty(): image_url = works.get_nowait() print('准备请求图片：' + image_url) # 图片名称 imagename = get_unique_str() + "." + image_url.split('.')[-1] res = requests.get(image_url) if res.status_code == 200: content = res.content image_folder = "./images/" if not os.path.isdir(image_folder): os.makedirs(image_folder) # 保存图片 with open('./images/' + imagename, 'ab') as f: f.write(content) print('图片已下载到本地：' + imagename) else: print('图片请求失败：' + image_url) def main(): # 1.获取图片地址 word = "美女" url = "http://image.baidu.com/search/flip?tn=baiduimage&ie=utf-8&word={}&pn=0".format(word) print('正请求图片地址...') res = requests.get(url) if res.status_code == 200: html = res.text # 利用正则表达式找到图片url pattern = '"objURL":"([^\s]*?(jpge|jpg|png|PNG|JPG))"' pic_urls = re.findall(pattern, html, re.S) for pic_url in pic_urls: # print(pic_url) works.put_nowait(pic_url[0]) else: print('图片列表访问失败！') # 设置协程去下载图片 tasks = list() for i in range(5): tasks.append(gevent.spawn(download_image)) # 执行任务 gevent.joinall(tasks) print('Done.') if __name__ == '__main__': main()
12、总结
""" 协程：在处理等待某些资源的同时，去做其他的任务。 进程、线程、协程对比： 进程是资源分配的单位 线程是操作系统调度的单位 进程切换需要的资源很最大，效率很低 线程切换需要的资源一般，效率一般（当然了在不考虑GIL的情况下） 协程切换任务资源很小，效率高 多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中 所以是并发 """
