python--进程，线程，协程

进程

进程的相关概念：http://www.cnblogs.com/chaguang/p/7818440.html

在python中创建进程用到了multiprocessing中的Process类

创建进程，使用Process中的def __init__(self, group=None, target=None, name=None, args=(), kwargs={})
参数：

• target：表示调用对象
• args：表示调用对象的位置参数元组
• kwargs：表示调用对象的字典
• name：为别名
• group：实质上不使用

方法：

• is_alive()：如果进程是运行的，返回True
• join([timeout])：主进程是否等待子进程结束，没有传递超时时间timeout则为等待子进程结束，如果设置了timeout，表示最多等待timeout时间
• run()：运行target参数指定的函数
• start()：启动进程，并调用子进程中的run方法
• terminate()：终止进程，不进行任何清理操作，如果该进程有子进程，那么就会变成僵尸进程

from multiprocessing import Process
g_i=1
def f1(i):
    global g_i
    g_i+=1
    print(i,g_i)
#进程的相关信息必须放在if __name__=="__main__":中，否则会报错
if __name__=="__main__":
    for i in range(5):
        #args后的括号内必须加,
        p=Process(target=f1,args=(i,))
        #启动进程
        p.start()

 注意事项

1. 在windows中Process()必须放到# if __name__ == '__main__':下
2. 参数args的括号中必须带,，否则会报错，例如args=(i,)
3. 进程的数据默认不共享的，各自有一份，所以在创建多进程的时候，系统开销比较大
   

 进程间的数据共享

• Array

from multiprocessing import Process,Array
import time
#Array相当于c中的数组，规定类型都需要一样
g_data=Array("i",[1,2,3,4,5,6])
    # 类型：
    # 'c': ctypes.c_char,  'u': ctypes.c_wchar,
    # 'b': ctypes.c_byte,  'B': ctypes.c_ubyte,
    # 'h': ctypes.c_short, 'H': ctypes.c_ushort,
    # 'i': ctypes.c_int,   'I': ctypes.c_uint,
    # 'l': ctypes.c_long,  'L': ctypes.c_ulong,
    # 'f': ctypes.c_float, 'd': ctypes.c_double
def sum(i):
   g_data[i]+=i

if __name__=="__main__" :
    for i in range(6):
        pro=Process(target=sum,args=(i,))
        pro.start()
        pro.join()

• manage.dict()

from multiprocessing import Process,Manager


def sum(dic,i):
    if i <5:
        dic[i]=i
    else:
        dic[i]="sdafsd"
    print(dic[i],dic.values())

if __name__=="__main__" :
    #创建一个Manager()对象
    ma = Manager()
    #创建一个进程间能够共享数据的“字典”，不需要类型统一
    dic = ma.dict()
    for i in range(6):
        pro=Process(target=sum,args=(dic,i,))
        pro.start()
        pro.join()






#

进程池

　　在python中，multiprocessing模块里提供了Pool的使用

进程池的一些方法：

• apply：同步执行，内部有调用了join，一个一个执行，主进程等子进程结束，它才结束
• apply_async：异步执行，并且可以设置回调函数，内部没有调用join，主进程不等子进程结束，可以调用pool对象.join()让主进程等待子进程，但是有一个限制，需要再其前面加p.close()（等任务执行完之后再终止）或者p.terminate()（立即终止所有的任务），调用函数的返回值可以传递给回调函数的参数
• close：关闭进程池

from multiprocessing import process,Pool
import time
def f1():
    print("f1")
    time.sleep(2)
    return 0
#f2的参数a是调用函数f1的返回值
def f2(a):
    print("f2:this is a callback~",a)
    return 1
if __name__=="__main__":
    #创建一个有5个进程数的进程池
    pool=Pool(5)
    for i in range(5):
        #使用进程池
        # pool.apply(func=f1)
        pool.apply_async(func=f1,callback=f2)
    print("end")
    pool.close()
    pool.join()

线程

线程的相关概念：http://www.cnblogs.com/chaguang/p/7818456.html

全局解释器锁GIL

 

threading模块

　　　　　　　　　　　　　　　　　　　　　　threading模块中的对象

Thread	表示一个执行线程的对象
Lock	锁原语对象
RLock	可重入锁对象，使单一线程可以获得已持有的锁
Condition	条件变量对象，使得一个线程等待另一个线程满足特定的“条件”
Event	条件变量的通用版本，任意数量的线程等待某个事件发生，在该事件发生后所有的线程都将被激活
Semaphore	为线程间共享的有限资源提供一个“计数器”，如果没有可用资源时，会被阻塞
BoundedSemaphore	与Semaphore相似，不过它不允许超过初始值
Timer	与Thread相似，不过它要在运行前等待一段时间
Barrier	创建一个“障碍”，必须达到指定数量的线程后才可以继续

 

 

 

 

 

 

 

 

 

 

　　threading模块中的对象Lock，RLock，Condition，Semaphore和BoundeSemaphore都包含上下文管理器，即可以使用with语句

Thread类

Thread对象的数据属性：

• name:线程名
• ident：线程的标识符
• daemon:布尔标志。表示该线程是否为守护线程，即进程退出的时候不需要等待这个线程执行完成

Thread对象方法：

start()                 开始执行该线程
run()                   定义线程功能的方法（通常在子类中被重写）
join([timeout])         直至启动的线程终止之前一直挂起，除非给出timeout，否则会一直阻塞
getName()               返回线程名
setName(name)           设置线程名

import threading

class myThread(threading.Thread):
    def __init__(self,func,args,name=''):
        threading.Thread.__init__(self)
        self.name=name
        self.func=func
        self.args=args
        
    def run(self):
        self.func(*self.args)
def fun(*args):
    print(args)

if __name__=="__main__":
    obj=myThread(fun,("诸葛",))
    obj.start()

 

线程锁Lock和RLock

　　为了解决线程同步的问题，python在threading模块中提供了Lock和RLock，互斥锁 同时只允许一个线程更改数据，有两种状态：锁定和未锁定。而且它也支持两个函数：获得锁和释放锁

import threading

g_num=1
g_lock = threading.RLock()

class myThread(threading.Thread):
    def __init__(self,func,args,name=''):
        threading.Thread.__init__(self)
        self.name=name
        self.func=func
        self.args=args

    def run(self):
        self.func(*self.args)
def fun(*args):
    print(args)
    global g_num
    #获得锁
    # g_lock.acquire()
    # g_num+=100
    # print(g_num)
    # g_lock.release()
    #上面的情况也可以写成with语句中，上下文管理器负责在进入之前调用acquire，执行完之后调用release
    with g_lock:
        g_num+=100
        print(g_num)

if __name__=="__main__":
    for i in range(5):
        obj=myThread(fun,("诸葛",))
        obj.start()

 

信号量（Semaphore）

　　Semaphore也是为了解决线程同步的问题，与互斥锁不同的是，Semaphore同时允许一定数量的线程更改数据，它是一个计数器，当资源消耗的时候递减，当资源释放的时候递增

import threading
import time
g_num=1
#设置资源数为5，即可以同时被5个线程执行临界区的内容
g_lock = threading.Semaphore(5)

class myThread(threading.Thread):
    def __init__(self,func,args,name=''):
        threading.Thread.__init__(self)
        self.name=name
        self.func=func
        self.args=args

    def run(self):
        self.func(*self.args)
def fun(*args):
    print("acquire")
    global g_num
    # 获得锁
    g_lock.acquire()
    print(args[1])
    time.sleep(2)
    print("release")
    #释放锁
    g_lock.release()


if __name__=="__main__":
    for i in range(5):
        obj=myThread(fun,("诸葛",1))
        obj.start()

事件(event)

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

from threading import Thread,Event
import time
#创建一个事件对象
event_obj=Event()

def f1():
    print("wait........")
    #等待event_obj.set()方法
    event_obj.wait()
    print("start.........")

if __name__=="__main__":
    for i in range(5):
        thread=Thread(target=f1)
        thread.start()

print("sleeping....")

time.sleep(3)
event_obj.set()

条件(Condition)

import threading
#该函数用来判断条件，返回True的话，con.wait_for（）向下执行
def condition_func():
    ...
    return True

def run(n):
    #获得锁
    con.acquire()
    #当condition_func返回True时候才向下执行，wait_for的参数需要是可以调用的对象
    con.wait_for(condition_func)
    print(n)
    # 释放锁
    con.release()

if __name__ == '__main__':
    #创建一个condition对象
    con = threading.Condition()
    for i in range(10):
        t = threading.Thread(target=run, args=(i,))
        t.start()

Timer

　　定时器，指定n秒后才开始执行操作

from threading import  Timer
def f1():
    print("start run....")

t=Timer(3,f1)
t.start()

线程池

#线程池
import threading
import contextlib
import queue

#用来当终止符
stopTask=object()

class ThreadPool(object):
    def __init__(self,maxNum,maxTaskNum=None):
        if maxTaskNum:
            self.taskQueue=queue.Queue(maxTaskNum)
        else:
            self.taskQueue=queue.Queue()
        #最大线程数
        self.maxNum=maxNum
        #空闲线程
        self.freeThread=[]
        #正在运行的线程
        self.runningThread=[]
        #判断是否要终止线程池，清空所有的任务
        self.terminate=False
    def Run(self,func,args,callback=None):
        #如果没有空闲的线程
        if len(self.freeThread)==0 or len(self.runningThread)<self.maxNum:
            #创建一个线程
            self.CreateThread()
        lis=(func,args,callback,)
        #将任务放在任务列表中
        self.taskQueue.put(lis)

    def CreateThread(self):
        obj=threading.Thread(target=self.call)
        #开始执行线程，让线程去处理任务
        obj.start()

    def call(self):
        #获取当前线程
        currentThread=threading.current_thread()
        #将线程添加到正在执行线程的列表中
        self.runningThread.append(currentThread)

        #开始取任务，然后处理任务
        task=self.taskQueue.get()
        while task!=stopTask:
            func,args,callback=task
            #执行任务中的处理函数,并将其参数传递给func函数
            ret=func(*args)
            if callback != None:
                #如果回调函数不为空，则将调用结果的返回值传给回调函数
                callback(ret)
            #************************************************#
            # #处理完任务,重新获取任务
            # self.freeThread.append(currentThread)
            # #如果终止符标记符为True,那么就向任务队列中投放终止符
            # if self.terminate:
            #     #self.taskQueue.put(stopTask)
            #     task=stopTask
            # else:
            #     task=self.taskQueue.get()
            # self.freeThread.remove(currentThread)
            #***********************************************#
            #上面的*号括着的内容等价于下面with里面的内容，主要是因为被@contextlib.contextmanager
            #修饰的worker_state函数
            with self.worker_state(self.freeThread,currentThread):
                if self.terminate:
                    task = stopTask
                else:
                    task = self.taskQueue.get()
        #收到了终止符号，终止线程
        else:
            self.runningThread.remove(currentThread)

    def Close(self):
        #关闭线程池
        threadNum=len(self.runningThread)
        while threadNum:
            self.taskQueue.put(stopTask)
            threadNum-=1

    def Terminate(self):
        #立即关闭线程池，清空所有的任务
        self.terminate=True
        while self.runningThread:
            self.taskQueue.put(stopTask)
        #清空任务对列
        self.taskQueue.queue.clear()
    #利用上下文管理
    @contextlib.contextmanager
    def worker_state(self, state_list, worker_thread):
        state_list.append(worker_thread)
        try:
            yield
        finally:
            state_list.remove(worker_thread)



def ca(re):
    print("callback,f1 return value %s"%re)

def f1(*args):
    print(args)
    return 0

obj=ThreadPool(3)

for i in range(5):
    obj.Run(f1,(11,22,33,),ca)

obj.Terminate()

 

协程

　　在协程中，控制可以从当前执行上下文跳转到程序的其它位置，并且可以在之后的任意时刻恢复当前执行上下文，控制从跳出点处继续执行。协程主要用在程序中有大量的IO操作的时候，这时候虽然可以用多线程的解决，但是这可能导致多个线程进行等待，这时就可以使用协程来解决，利用一个线程去等待多个IO操作。

from greenlet import greenlet

def test1():
    print("12")
    gr2.switch()
    print("34")
    gr2.switch()

def test2():
    print("56")
    gr1.switch()
    print("78")

gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()
######输出############
12
56
34
78

# from gevent import monkey; monkey.patch_socket()
import gevent

def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        gevent.sleep()

# g1 = gevent.spawn(f, 5)
# g2 = gevent.spawn(f, 5)
# g3 = gevent.spawn(f, 5)
# g1.join()
# g2.join()
# g3.join()
#或者写成下面的形式
gevent.joinall([
    gevent.spawn(f,5),
    gevent.spawn(f,5),
    gevent.spawn(f,5),
])