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()

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/'),

参考资料：

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

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

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