python第四课——线程、进程、协程

时间：2023-04-28 22:26:40

内容概要

1、进程与线程优、缺点的比较

2、适用情况

3、线程

　　线程的创建

　　setDaemon

　　join

　　event

　　RLock

　　队列

4、进程

　　创建进程

　　setDaemon

　　join

　　线程与进程，数据之间是否共享对比

　　特殊的数据容器

　　进程池

5、协程

1、进程与线程优、缺点的比较

总言：使用进程和线程的目的，提高执行效率。

进程：

　　优点：能利用机器的多核性能，同时进行多个操作。

　　缺点：需要耗费资源，重新开辟内存空间，耗内存。

线程：

　　优点：共享内存（资源），做IO操作时，可以创造并发操作。

　　缺点：抢占资源。

总结：进程并不是越多越好，最好CPU个数 = 进程个数。

　　   线程也并不是越多越好，应根据业务需求来确定个数，因为请求上下文切换非常耗时。

2、适用情况

IO密集型（不用CPU）   ：适合多线程

计算密集型（要用CPU）：适合多进程

3、线程

　　（1）线程的创建（threading模块）

 import threading #导入该模块

 import time

 def f0():

     pass

 def f1(a1,a2):

     time.sleep(1)

     print(a1,a2)

     f0()

 #创建子线程，任务为f1()，参数为args的元祖

 t = threading.Thread(target=f1,args=(123,456,))

 #默认setDaemon为false，主线程要等待子线程执行完毕后再结束

 #设置为True后，就不等待

 t.setDaemon(True)

 t.start() #告诉线程我们准备好了

　　（2）主线程是否等待子线程

　　t.setDaemon（True/False）

　　用于设置主线程执行完毕后，是否等待子线程，默认为false，要等待。

　　（3）主线程是否等待某个子线程执行完毕

　　t.join（）  一直等待

　　t.join（2）最多等待该子线程2s

　　（4）线程锁RLock

　　避免因并发操作而造成脏数据，线程锁能锁住全部子线程，同一时刻允许一个线程执行操作。

 #未使用线程锁时

 import threading

 import time

 gl_num = 0

 def show(arg):

     global gl_num

     time.sleep(0.5)

     gl_num +=1

     print(gl_num)

 #开了10个线程，同时都对全局变量gl_num进行操作

 for i in range(10):

     t = threading.Thread(target=show, args=(i,))

     t.start()

 print('main thread stop')

　　

 #使用了线程锁时

 import threading

 import time

 gl_num = 0

 lock = threading.RLock() #创建锁

 def Func():

     lock.acquire() #锁定

     global gl_num

     gl_num += 1

     time.sleep(0.25)

     print(gl_num)

     lock.release() #释放锁

 for i in range(10):

     t = threading.Thread(target=Func)

     t.start()

 print('main thread stop')

　　（5）事件（Event）

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

　　event.wait（）  等待绿灯开启，再继续执行

　　event.clear（）设为红灯

　　event.set（）   设为绿灯

　　

 import threading

 def do(event):

     print('start')

     event.wait() #阻塞住，等待绿灯。event_obj.set()语句执行后，又回来继续执行下一句

     print('execute')

 event_obj = threading.Event()

 for i in range(3):

     t = threading.Thread(target=do, args=(event_obj,))

     t.start()

 event_obj.clear() #设为红灯

 inp = input('input:')

 if inp == 'true':

     event_obj.set() #设为绿灯

执行结果：

 start

 start

 start

 input:true

 execute

 execute

 execute

（6）生产者消费者模型、队列（先进先出）（queue模块）

4、进程

（1）创建进程（multiprocessing模块）

 import multiprocessing

 import time

 def f1(a1):

     time.sleep(3)

     print(a1)

 if __name__ == '__main__': #Windows上，进程语句必须放在main里面

     #创建进程，任务为执行f1()，参数为11，由元祖封装

     t = multiprocessing.Process(target=f1,args=(11,))

     # 当daemon设为true时，主进程结束后就不再等待子进程了，默认为false要等待

     t.daemon = True  #所以结果没有打印出 11

     t.start()

     t = multiprocessing.Process(target=f1,args=(22,))

     t.start()

     print('end')

　　　　

（2）主进程是否等待子进程

　　t.setDaemon（True/False）

　　用于设置主进程执行完毕后，是否等待子进程，默认为false，要等待。

　（3）主进程是否等待某个子进程执行完毕

　　t.join（）  一直等待

　　t.join（2）最多等待该子进程2s

　　（4）线程与进程，数据之间是否共享对比

　　默认每个进程之间的数据是不共享的，各做各的。

　　而每个线程之间的数据是共享的。　　

 #进程操作时，数据是不共享的

 from multiprocessing import Process

 li = []

 def foo(i):

     li.append(i)

     print('say hi',li)

 if __name__ == '__main__':

     for i in range(10):

         p = Process(target=foo,args=(i,))

         p.start()

结果为：

 say hi [0]

 say hi [2]

 say hi [1]

 say hi [3]

 say hi [4]

 say hi [5]

 say hi [6]

 say hi [7]

 say hi [9]

 say hi [8]

线程处理时，数据是共享的，将process改为thread，结果为：

 say hi [0]

 say hi [0, 1]

 say hi [0, 1, 2]

 say hi [0, 1, 2, 3]

 say hi [0, 1, 2, 3, 4]

 say hi [0, 1, 2, 3, 4, 5]

 say hi [0, 1, 2, 3, 4, 5, 6]

 say hi [0, 1, 2, 3, 4, 5, 6, 7]

 say hi [0, 1, 2, 3, 4, 5, 6, 7, 8]

 say hi [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

　　（5）特殊的数据容器

　　如果想要多个进程同时操作一份数据，则需要特殊的容器。

　　方法一：Array数组（不推荐）

　　　　a.创建时需要规定大小，切不能改变。

　　　　b.内部数据必须统一为相同类型，字符串、数字等。

　　方法二：manager.dict（）共享数据（推荐）

　　　　创建： m = Manager（）

　　　　　　    dict = m.dict（）

 from multiprocessing import Process,Manager

 def Foo(i,dic):

     dic[i] = 100+i

     print(len(dic))

     # for k,v in dic.items():

     #     print(k,v)

 if __name__ == '__main__':

     manager = Manager()

     dic = manager.dict()

     # dic = {} #dic为普通字典时，返回值为    1   1

     for i in range(2):

         p = Process(target=Foo,args=(i,dic))

         p.start()

         p.join()

返回值为：1   2

　　（6）进程池（python中已创建好） pool

　　

 from multiprocessing import  Pool

 import time

 def f1(a1):

     time.sleep(1)

     print(a1)

     return 1000

 def f2(arg):

     print(arg)

 if __name__ == '__main__':

     pool = Pool(5)

     # pool.apply(f1,(2,))

     for i in range(10):

         pool.apply_async(func=f1, args=(i,), callback=f2)#特别注意args跟的参数为元祖类型

         #callback=f2表示回调函数，将f1 return的值作为参数传给f2

     pool.close()

     pool.join()#等待子进程执行完
pool.apply（）和pool.apply_async（）对比：
pool.apply（） ：每一个任务都是排队执行的，内部有join（）方法，会等待子进程
pool.apply_async（）：每一个任务都是并发执行，且可以设置回调函数，内部无join（）方法，
进程deamon = true，不等待子进程，要想等待子进程，需先pool.close（），再pool.join（）

5、协程（高性能代名词）

线程和进程的操作时程序出发系统接口，最后的执行者是系统，协程的操作则是程序员。

存在意义：只使用一个线程，在一个线程中规定某个代码块执行顺序。
适用于： IO密集型操作

方法一：greenlet模块
　　　　需手动切换任务（不推荐）

方法二：gevent模块（本质也是基于greenlet）
　　　　自动切换任务，谁先回来就先处理谁（推荐）

 import gevent

 def foo():

     print('')

     gevent.sleep(0) #切换标志

     print('')

 def bar():

     print('')

     gevent.sleep(0) #切换标志

     print('')

 gevent.joinall([

     gevent.spawn(foo),

     gevent.spawn(bar),

 ])
结果为： 1   3   2   4

补充知识点：http://www.cnblogs.com/wupeiqi/articles/6229292.html

相关文章