python实现多任务方式

什么是多任务？

就是操作系统可以同时运行多个任务

多任务的执行方式

并发：交替执行，是假的多任务
并行：同时执行，是真的多任务

第一种多任务的实现方式：多线程

python线程的两种写法(第一种会比较常用)：
第一种：

def say(): print("我在说话") def sing(): print("我在唱歌") time.sleep(1) if __name__ == "__main__": t1 = threading.Thread(target=say) t2 = threading.Thread(target=sing) t1.start() t2.start()

第二种，通过继承Thread类完成创建线程：

class MyThread(threading.Thread): def run(self): for i in range(3): time.sleep(1) msg = "I'm " + self.name + " @ " + str(i) # name属性中保存的是当前线程的名字 print(msg) if __name__ == "__main": t = MyThread() t.start()

主线程等待所有子线程执行完才结束

多线程中的全局变量

多线程允许共享全局变量，但全局变量存在资源竞争的问题，导致计算出的结果与预期不符。比如相加到一定数值，得到的结果可能会比预期的小，数值越大结果越明显。

这是因为线程A可能运行到一半，线程B就开始运行，两个线程都竞争全局变量的时候会出现资源竞争问题。

解决资源竞争的问题是使用同步概念，用互斥锁解决，线程A运行时候上了互斥锁，线程B需要等到线程A完成程序后才能运行，这样就避免了资源竞争。

但互斥锁又可能引发死锁的问题。当线程A拥有X锁等待Y锁，线程B拥有Y锁等待X锁，两者都堵塞了在请求对方拥有的资源，导致死锁。

解决死锁的方法有两种：
1，程序实现时尽量避免（银行家算法）
2，添加超时时间

 

第二种多任务的实现方式：多进程

理解进程和程序：

通俗的讲，运行中的叫进程，没运行的叫程序，程序只有一个，而进程可以有多个

多进程python实现：

def say(): print("我在说话") def sing(): print("我在唱歌") time.sleep(1) if __name__ == "__main__": t1 = multiprocessing.Process(target=say) t2 = multiprocessing.Process(target=sing) t1.start() t2.start()

进程，线程对比

进程是资源分配的基本单位，线程是操作系统调度的基本单位（执行即调度），一个进程至少有一个主线程，线程依赖于进程，没有进程就没有线程

多进程通信

多进程之间通过队列来实现数据共享：

def download(): # 模拟从网上下载数据 data = [11, 22, 33, 44] # 向队列中写入数据 for temp in data: q.put(temp) print("---下载器已经下载完了数据并且存入到队列中---") def analysis(q): waitting_analysis_data = list() # 从队列中获取数据 while True: data = q.get() waitting_analysis_data.append(data) if q.empty(): break # 模拟数据处理 print(waitting_analysis_data) def main(): # 1.创建一个队列 q = multiprocessing.Queue() # 2.创建多个进程，将队列的引用当作实参进行传递到里面 p1 = multiprocessing.Process(target=download, args=(q,)) p2 = multiprocessing.Process(target=analysis, args=(q,)) p1.start() p2.start() if __name__ == "__main__": main()

进程池Pool

进程池Pool的作用是缓冲，减少进程创建和销毁

进程池用python实现如下：

def worker(msg): t_start = time.time() print("%s开始执行，进程号为%d" % (msg, os.getpid())) # random.random()随机生成0-1之间的浮点数 time_sleep(random.random()*2) t_stop = time.time() print(msg, "执行完毕，耗时%0.2f" % (t_stop-t.start)) po = Pool(3) for i in range(0, 10): # Pool().apply_async(要调用的目标, (传递给目标的参数元祖,)) # 每次循环将会用空闲出来的子进程去调用目标 po.apply_async(worker,(i,)) print("-----start-----") po.close() # 关闭进程池，关闭后po不再接收新的请求 po.join() # 等待po中所有子进程执行完成，必须放在close语句之后 print("-------end------")

 

第三种多任务的实现方式：协程

迭代器

数据类型可不可迭代：
可迭代：字符串，列表，元组，字典，集合
不可迭代：数字

如果想要一个对象成为一个可以迭代的对象，即可以使用for，那么必须实现__iter__方法，返回一个对象的引用。iter()函数会自动调用__iter__的返回值，__iter__方法的返回值是一个迭代器。

class Classmate(object): def __init__(self): self.names = list() self.current_num = 0 def add(self, name): self.names.append(name) def __iter__(self): return self def __next__(self): if self.current_num < len(self.names): ret = self.names[self.current_num] self.current_num = 1 else: raise StopIteration classmate = Classmate() classmate.add("老王") classmate.add("王二") classmate.add("张三") # print("是否可迭代：", isinstance(classmate, Iterable)) # classmate_iterator = iter(classmate) # print("是否是迭代器", isinstance(classmate_iterator, Iterator)) # print(next(classmate_iterator)) for name in classmate: print(name)

生成器

生成器是特殊的迭代器。所以生成器也可以迭代要创建一个生成器
第一种方法，只要把一个列表生成式的[]改成():

a = [x*2 for x in range(5)] # a是一个列表 b = (x*2 for x in range(5)) # b是一个生成器，<generator object <genexpr> at 0x7f626c132bd0>

第二种方法

如果一个函数中有yield语句，那么这个就不再是函数，而是一个生成器，如果在调用一个函数时。发现这个函数里有yield,不是调用函数，而是创建一个生成器。

def create_num(all_num): print("------1------") # a, b = 0, 1 current_num = 0 while current_num < all_num: print("------2------") # print(a) yield a print("------3------") a, b = b, a+b current_num += 1 print("------4------") obj = create_num(10) ret = next(obj) print(ret) ret = next(obj) print(ret) 输出结果： ------1------ ------2------ 0 ------3------ ------4------ ------2------ 1

生成器第二次迭代的时候并不会从头开始执行，而是从上一次生成器暂停的位置开始执行

协程

用yeild实现多任务，其实也就叫协程，下面例子t1和t2两个任务交替执行

def task_1(): while True: print("------1-----") time.sleep(0.1) yield def task_2(): while True: print("-----2-----") time.sleep(0.1) yield def main(): t1 = task_1() t2 = task_2() # 先让t1运行一会，当t1中遇到yield的时候，再返回到24行，然后 # 执行t2,当它遇到yield的时候，再次切换到t1中 # 这样t1/t2/t1/t2的交替运行，最终实现了多任务，协程 while True: next(t1) next(t2)

切换开销：协程<线程<进程

实际项目中实现协程一般是用greenlet、gevent完成多任务，只要在程序中加入monkey.patch_all()，就可以将程序中用到的耗时操作
的代码换成gevent中自己实现的模块

monkey.patch_all() def coroutune_work(coroutinue_name): for i in range(10): print(coroutinue_name, i) time.sleep(random.random()) gevent.joinall([ gevent.spawn(coroutine_work, "work1") gevent.spawn(coroutine_work, "work2") ])

总结

进程是资源分配的基本单位
线程是操作系统调度的基本单位
进程切换开销大，效率低
线程切换开销一般，效率一般（不考虑GIL锁的情况）
协程切换开销最小，效率高
多进程，多线程根据cpu核数不一样可能是并行的，但协程是在一个线程中，所以是并发