python进阶——进程/线程/协程

1 python线程

python中Threading模块用于提供线程相关的操作，线程是应用程序中执行的最小单元。

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import threading
 import time

 def show(arg):
     time.sleep(1)
     print 'thread'+str(arg)

 for i in range(10):
     #调用构造函数，实例化对象，第1个参数是线程执行的函数，第2个参数是函数参数
     t = threading.Thread(target=show, args=(i,))
     #线程准备就绪，等待CPU调度
     t.start()  

 print 'main thread stop'

上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。

为什么是分片执行？

python中有一个GIL（Global Interpreter Lock 全局解释器锁 ），即在同一时刻只有一个线程在执行，底层自动进行上下文切换。一个应用程序一般只存在一个进程，在进程中存在一个线程，线程是应用程序的最小执行单元。如果该进程中存在多个线程，其实也是串行执行的，即相当于在每个进程的出口，多个线程任务请求cpu调度，因为GIL的原因，只有一个线程能够被调度，所以单个进程不管有多少线程只能调度一个cpu。

线程模块threading中的方法：

start       线程准备就绪，等待CPU调度

setName     为线程设置名称

getName     获取线程名称

setDaemon   设置为后台线程或前台线程（默认）

如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止

如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

join        逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义

run         线程被cpu调度后执行Thread类对象的run方法

2 线程锁

由于线程是随机调度，可能某个线程只执行一部分代码，cpu就被调度执行其它线程了。下面是例子：

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import threading
 import time

 gl_num = 0

 def show(arg):
     global gl_num
     time.sleep(1)
     gl_num +=1
     print gl_num

 for i in range(10):
     t = threading.Thread(target=show, args=(i,))
     t.start()

 print 'main thread stop'

没加线程锁代码

执行结果

 #!/usr/bin/env python
 #coding:utf-8

 import threading
 import time

 gl_num = 0

 lock = threading.RLock() #实例化线程锁

 def Func():
     lock.acquire() #获取线程锁
     global gl_num
     gl_num +=1
     time.sleep(1)
     print gl_num
     lock.release() #释放线程锁，这里注意，在使用线程锁的时候不能把锁，写在代码中，否则会造成阻塞，看起来“像”单线程

 for i in range(10):
     t = threading.Thread(target=Func)
     t.start()

加线程锁后代码

执行结果

3 event

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

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

• clear：将“Flag”设置为False
• set：将“Flag”设置为True

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import threading

 def do(event):
     print 'start'
     event.wait() #执行event对象wait方法，然后他们停下来，等待“Flag”为True
     print 'execute'

 event_obj = threading.Event() #创建事件的对象

 for i in range(10):
     t = threading.Thread(target=do, args=(event_obj,)) #event对象传给每个线程
     t.start()

 event_obj.clear()  #设置"Flag"为Flase

 inp = raw_input('input:')
 if inp == 'true':
     event_obj.set()

event事件代码

4 python进程

 from multiprocessing import Process

 def foo(i):
     print 'say hi',i

 for i in range(10):
     p = Process(target=foo,args=(i,))
     p.start()

多进程代码

   注意：由于进程之间的数据需要各自持有一份，所以创建进程需要非常大的开销。并且python不能在Windows下创建进程！在使用多进程的时候，最好是创建和CPU核数相等进程数，默认进程之间相互独立，如果想让进程之间数据共享，就得有个特殊的数据结构，这个数据结构就可以理解为他有穿墙的功能。

   进程数据共享

进程各自持有一份数据，默认无法共享数据

 #!/usr/bin/env python
 #coding:utf-8

 from multiprocessing import Process
 from multiprocessing import Manager

 import time

 li = []

 def foo(i):
     li.append(i)
     print 'say hi',li

 for i in range(10):
     p = Process(target=foo,args=(i,))
     p.start()

 print 'ending',li

默认无法共享数据

使用特殊的数据结构来实现进程共享数据

 默认进程之间是相互独立的，如果想让进程之间共享数据，那么在python中需要借助特殊的数据结构

 第1种方法：
 #通过特殊的数据结构Array

 from multiprocessing import Process
 from multiprocessing import Array

 #创建1个只包含数字类型的Array，可以看做是”类型与列表“组合的数据结构
 temp = Array('i', [11,22,33,44]) #其中i是数据类型，这里i表示整型，后面就是python中的列表

 def Foo(i):
     temp[i] = 100+i
     for item in temp:
         print i,'----->',item

 for i in range(2):
     p = Process(target=Foo,args=(i,))
     p.start()

 第二种方法：
 #通过特殊的数据结构manage.dict()共享数据

 from multiprocessing import Process
 from multiprocessing import Manager 

 #创建Manager对象manage
 manage = Manager()
 dic = manage.dict() #创建字典对象dic，这里的字典和python中字典使用方法一样！

 def Foo(i):
     dic[i] = 100+i
     print dic.values()

 for i in range(2):
     p = Process(target=Foo,args=(i,))
     p.start()
     p.join() #注意此处调用join方法，否则报错

两种特殊数据结构实现进程间数据共享

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 from multiprocessing import Process
 from multiprocessing import Array
 from multiprocessing import RLock

 def Foo(lock,temp,i):
     lock.acquire()  #获取锁
     temp[0] = 100+i
     for item in temp:
         print i,'--->',item
     lock.release()  #释放锁

 lock = RLock()  #生成锁对象
 temp = Array('i', [11, 22, 33, 44]) #用特殊数据结构Array实现进程间共享数据

 for i in range(20):
     p = Process(target=Foo,args=(lock,temp,i,))
     p.start()

进程锁

5 进程池

进程池内部维护一个进程序列，当使用时去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中有两个方法：apply 阻塞   apply_async 非阻塞

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 from  multiprocessing import Process
 from  multiprocessing import Pool
 import time

 def Foo(i):
     time.sleep(2)
     return i+100

 def Bar(arg):
     print arg

 pool = Pool(5) #创建一个进程池
 #print pool.apply(Foo,(1,))#向进程池申请一个进程去执行Foo方法
 #print pool.apply_async(func =Foo, args=(1,)).get() #获取返回值

 for i in range(10):
     #Foo函数的执行结果返回，作为Bar函数的参数
     pool.apply_async(func=Foo, args=(i,),callback=Bar)

 print 'end'
 pool.close()
 pool.join()#进程池中进程执行完毕后终止程序，如果不调用jion方法，那么主进程执行完后程序直接关闭。

进程池

6 协程

线程和进程都是由操作系统开辟的，即python进程和线程内部都是调用操作系统的API，这样系统的开销比较大。而对于协程，它是由程序员开辟的，由程序员进行控制，不需要调用操作系统的API。对于线程和进程来说，它是由CPU调度的，而协程完全由程序员控制，不需要CPU调度。
    协程的意义：对于多线程，CPU通过切片的方式来执行线程，线程切换时需要耗时（保存状态，下次继续）。协程则存在于线程中，在线程中控制代码块的执行顺序。
    适用场景：在其他语言中，协程存在的意义不大，因为多线程可以解决I/O操作问题，但是python存在GIL（Global Interpreter Lock 全局解释器锁 ），在同一时刻只能执行1个线程，所以，如果一个线程里I/O操作特别多，协程就比较适用，当进行IO操作时，可以调度执行其它代码段，避免由于IO操作时的阻塞导致CPU闲置

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 #导入协程模块greenlet
 from greenlet import greenlet  

 def test1():
     print 12
     gr2.switch() #切换到协程2
     print 34     #协程2切换回来之后，执行此语句，和yield类似
     gr2.switch() #切换到协程2

 def test2():
     print 56
     gr1.switch() #切换到协程1
     print 78

 gr1 = greenlet(test1)  #创建了一个协程对象
 gr2 = greenlet(test2)

 gr1.switch() #执行协程1 

实例

协程：把一个线程分成了多个协程，达到控制代码段的执行顺序，协程就是对线程的分片。上面的实例需要手动控制协程的执行顺序，因为greenlet需要人为的指定调度顺序的，而gevent对greenlet进行了封装，达到遇到IO操作自动切换。实例如下

 from gevent import monkey; monkey.patch_all()
 import gevent
 import urllib2

 def f(url):
     print('GET: %s' % url)
     resp = urllib2.urlopen(url) #当遇到I/O操作时，会调用协程操作，程序继续执行，协程就阻塞等待数据的返回
     data = resp.read()
     print('%d bytes received from %s.' % (len(data), url))

 gevent.joinall([
         gevent.spawn(f, 'https://www.python.org/'),  #f是调用的方法，其后的是传递的参数
         gevent.spawn(f, 'https://www.yahoo.com/'),
         gevent.spawn(f, 'https://github.com/'),

gevent实例

参考资料：

http://www.cnblogs.com/wupeiqi/articles/5040827.html

http://www.cnblogs.com/luotianshuai/p/5111587.html

http://www.cnblogs.com/kaituorensheng/p/4445418.html(进程池)