python 多进程

一、Python  Multiprocessing  功能介绍

　 multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。

1、Multiprocessing .Process类的介绍

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

　参数介绍

group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称

　方法介绍：

p.start()：启动进程，并调用该子进程中的p.run() 
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程

   属性介绍：

p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid
p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

2、Multiprocessing  异常类介绍

1）ProcessError

exception multiprocessing.ProcessError

    The base class of all multiprocessing exceptions.

2）BufferTooShort

exception multiprocessing.BufferTooShort

    Exception raised by Connection.recv_bytes_into() when the supplied buffer object is too small for the message read.

    If e is an instance of BufferTooShort then e.args[0] will give the message as a byte string.

 3）AuthenticationError

exception multiprocessing.AuthenticationError

    Raised when there is an authentication error.

4）TimeoutError

exception multiprocessing.TimeoutError

    Raised by methods with a timeout when the timeout expires.

二、创建进程四种方式

1、通过Multiprocessing模块中的Process类，创建Process对象，通过对象参数target=“需要执行的子进程”

代码示例：

#开进程的方法一:
import time
import random
from multiprocessing import Process
def piao(name):
    print('%s piaoing' %name)
    time.sleep(random.randrange(1,5))
    print('%s piao end' %name)


p1=Process(target=piao,args=('egon',)) #必须加,号
p2=Process(target=piao,args=('alex',))
p3=Process(target=piao,args=('wupeqi',))
p4=Process(target=piao,args=('yuanhao',))

p1.start()
p2.start()
p3.start()
p4.start()
print('主线程')

2、通过继承Process类，创建子进程

代码示例：

import random
from multiprocessing import Process

class Piao(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print('%s piaoing' %self.name)

        time.sleep(random.randrange(1,5))
        print('%s piao end' %self.name)

p1=Piao('egon')
p2=Piao('alex')
p3=Piao('wupeiqi')
p4=Piao('yuanhao')

p1.start() #start会自动调用run
p2.start()
p3.start()
p4.start()
print('主线程')

3、Python的OS模块封装了常见的系统调用，多进程的调用就是fork，可以使用python创建多进程。

import os
 
ret = os.fork() # 返回值等于0时，子进程
print(ret)
if ret>0:
    print("---父进程--%d-"%os.getpid())
else:
    print("---子进程---%d-%d-"%(os.getpid(),os.getppid()))

 4、进程池Pool

pool 函数

Pool([numprocess  [,initializer [, initargs]]]):创建进程池 

参数介绍：

1 numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值
2 initializer：是每个工作进程启动时要执行的可调用对象，默认为None
3 initargs：是要传给initializer的参数组

　方法介绍：

p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()
p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。   
p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用

　其他方法

方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法
obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():如果调用完成，返回True
obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):等待结果变为可用。
obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

 样例：

from multiprocessing import Pool
import os,time
def work(n):
    print('%s run' %os.getpid())
    time.sleep(3)
    return n**2

if __name__ == '__main__':
    p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res=p.apply(work,args=(i,)) #同步调用，直到本次任务执行完毕拿到res，等待任务work执行的过程中可能有阻塞也可能没有阻塞，但不管该任务是否存在阻塞，同步调用都会在原地等着，只是等的过程中若是任务发生了阻塞就会被夺走cpu的执行权限
        res_l.append(res)
    print(res_l)

同步调用apply

from multiprocessing import Pool
import os,time
def work(n):
    print('%s run' %os.getpid())
    time.sleep(3)
    return n**2

if __name__ == '__main__':
    p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res=p.apply_async(work,args=(i,)) #同步运行,阻塞、直到本次任务执行完毕拿到res
        res_l.append(res)

    #异步apply_async用法：如果使用异步提交的任务，主进程需要使用jion，等待进程池内任务都处理完，然后可以用get收集结果，否则，主进程结束，进程池可能还没来得及执行，也就跟着一起结束了
    p.close()
    p.join()
    for res in res_l:
        print(res.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

异步调用apply_async

#一：使用进程池（异步调用,apply_async）
#详解：apply_async与apply


#coding: utf-8
from multiprocessing import Process,Pool
import time

def func(msg):
    print( "msg:", msg)
    time.sleep(1)
    return msg

if __name__ == "__main__":
    pool = Pool(processes = 3)
    res_l=[]
    for i in range(10):
        msg = "hello %d" %(i)
        res=pool.apply_async(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        res_l.append(res)
    print("==============================>") #没有后面的join，或get，则程序整体结束，进程池中的任务还没来得及全部执行完也都跟着主进程一起结束了

    pool.close() #关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束

    print(res_l) #看到的是<multiprocessing.pool.ApplyResult object at 0x10357c4e0>对象组成的列表,而非最终的结果,但这一步是在join后执行的,证明结果已经计算完毕,剩下的事情就是调用每个对象下的get方法去获取结果
    for i in res_l:
        print(i.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

#二：使用进程池（同步调用,apply）
#coding: utf-8
from multiprocessing import Process,Pool
import time

def func(msg):
    print( "msg:", msg)
    time.sleep(0.1)
    return msg

if __name__ == "__main__":
    pool = Pool(processes = 3)
    res_l=[]
    for i in range(10):
        msg = "hello %d" %(i)
        res=pool.apply(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        res_l.append(res) #同步执行，即执行完一个拿到结果，再去执行另外一个
    print("==============================>")
    pool.close()
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束

    print(res_l) #看到的就是最终的结果组成的列表
    for i in res_l: #apply是同步的，所以直接得到结果，没有get()方法
        print(i)

三、进程间通讯方法：

　　1、进程间通讯   方式有： 共享内存、队列，管道、信号

　　1）共享内存（Value, Array）Value, Array 不安全  ------->  升级  使用 multiprocessing.sharedctypes  安全

　　样例：

from multiprocessing import Process, Value, Array

def f(n, a):
    n.value = 3.1415927
    for i in range(len(a)):
        a[i] = -a[i]

if __name__ == '__main__':
    num = Value('d', 0.0)
    arr = Array('i', range(10))

    p = Process(target=f, args=(num, arr))
    p.start()
    p.join()

    print(num.value)
    print(arr[:])

　　　　a 、multiprocessing.sharedctypes

multiprocessing.sharedctypes.RawArray(typecode_or_type, size_or_initializer)
    Return a ctypes array allocated from shared memory.

multiprocessing.sharedctypes.RawValue(typecode_or_type, *args)
    Return a ctypes object allocated from shared memory.

multiprocessing.sharedctypes.Array(typecode_or_type, size_or_initializer, *, lock=True)¶
    
multiprocessing.sharedctypes.Value(typecode_or_type, *args, lock=True)¶

multiprocessing.sharedctypes.copy(obj)
    Return a ctypes object allocated from shared memory which is a copy of the ctypes object obj.

 multiprocessing.sharedctypes.synchronized(obj[, lock])
    Return a process-safe wrapper object for a ctypes object which uses lock to synchronize access.

　　样例:

from multiprocessing import Process, Lock
from multiprocessing.sharedctypes import Value, Array
from ctypes import Structure, c_double

class Point(Structure):
    _fields_ = [('x', c_double), ('y', c_double)]

def modify(n, x, s, A):
    n.value **= 2
    x.value **= 2
    s.value = s.value.upper()
    for a in A:
        a.x **= 2
        a.y **= 2

if __name__ == '__main__':
    lock = Lock()

    n = Value('i', 7)
    x = Value(c_double, 1.0/3.0, lock=False)
    s = Array('c', b'hello world', lock=lock)
    A = Array(Point, [(1.875,-6.25), (-5.75,2.0), (2.375,9.5)], lock=lock)

    p = Process(target=modify, args=(n, x, s, A))
    p.start()
    p.join()

    print(n.value)
    print(x.value)
    print(s.value)
    print([(a.x, a.y) for a in A])

2) 队列（multiprocessing.Queues）　

队列类
     multiprocessing.Queue([maxsize])   

类参数及方法：
    参数：maxsize   #设置队列个数     
    方法： 
    Queue.qsize()：返回当前队列包含的消息数量；
    Queue.empty()：如果队列为空，返回True，反之False ；
    Queue.full()：如果队列满了，返回True,反之False；
    Queue.get():获取队列中的一条消息，然后将其从列队中移除，可传参超时时长。
    Queue.get_nowait()：相当Queue.get(False),取不到值时触发异常：Empty；
    Queue.put():将一个值添加进数列，可传参超时时长。
    Queue.put_nowait():相当于Queue.get(False),当队列满了时报错：Full。
    Queue.cancel_join_thread():不会在进程退出时自动连接后台线程。可以防止     join_thread()方法阻塞
    Queue.close():关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。
    Queue.join_thread()：连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行

　样例：

'''
multiprocessing模块支持进程间通信的两种主要形式:管道和队列
都是基于消息传递实现的,但是队列接口
'''

from multiprocessing import Process,Queue
import time
q=Queue(3)


#put ,get ,put_nowait,get_nowait,full,empty
q.put(3)
q.put(3)
q.put(3)
print(q.full()) #满了

print(q.get())
print(q.get())
print(q.get())
print(q.empty()) #空了

补充：multiprocessing 提供  三种队列：Queues ，SimpleQueue，JoinableQueue

SimpleQueue：

class SimpleQueue(object):
    def empty(self):
        return False

    def get(self):
        pass

    def put(self, item):
        pass

JoinableQueue：

class JoinableQueue(multiprocessing.Queue):
    def task_done(self):
        pass

    def join(self):
        pass

三种队列区别：

multiprocessing.Queue默认不支持join()和task_done操作，这两个支持需要使用JoinableQueue对象。

JoinableQueue ：补充扩展 Queue 方法

SimpleQueue是一个简化的队列，去掉了Queue中的buffer，没有了使用Queue可能出现的问题，但是put和get方法都是阻塞的并且没有超时控制

3）管道(Pipe)

#创建管道的类： Pipe([duplex]):　　　　在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道
方法原形：
def Pipe(duplex=True):
    return Connection(), Connection()
　　#参数介绍： dumplex:　　　　默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。
返回 Connection 类
class Connection(object)
    Connection方法：
#主要方法：
    conn1.recv():　　　　接收conn2.send(obj)发送的对象。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。
    conn1.send(obj):　　　　通过连接发送对象。obj是与序列化兼容的任意对象
 #其他方法：
conn1.close():　　关闭连接。如果conn1被垃圾回收，将自动调用此方法
conn1.fileno():　　　　返回连接使用的整数文件描述符
conn1.poll([timeout]):　　　　如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。 
conn1.recv_bytes([maxlength]):　　　　接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。
conn.send_bytes(buffer [, offset [, size]])：　　　　　　通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收    
conn1.recv_bytes_into(buffer [, offset]):　　　　接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

介绍

 样例：

from multiprocessing import Process,Pipe

import time,os
def consumer(p,name):
    left,right=p
    left.close()
    while True:
        try:
            baozi=right.recv()
            print('%s 收到包子:%s' %(name,baozi))
        except EOFError:
            right.close()
            break
def producer(seq,p):
    left,right=p
    right.close()
    for i in seq:
        left.send(i)
        # time.sleep(1)
    else:
        left.close()
if __name__ == '__main__':
    left,right=Pipe()

    c1=Process(target=consumer,args=((left,right),'c1'))
    c1.start()


    seq=(i for i in range(10))
    producer(seq,(left,right))

    right.close()
    left.close()

    c1.join()
    print('主进程')
#基于管道实现进程间通信（与队列的方式是类似的，队列就是管道加锁实现的）

4）信号（signal）

样例：

import os  
import signal  
from time import sleep  
    
def onsigchld(a,b):  
  print '收到子进程结束信号' 
signal.signal(signal.SIGCHLD,onsigchld)  
    
pid = os.fork()  
if pid == 0:  
  print '我是子进程,pid是',os.getpid()  
  sleep(2)  
else:  
  print '我是父进程,pid是',os.getpid()  
  os.wait() #等待子进程结束  

import os  
import signal  
from time import sleep  
import Queue  
    
QCOUNT = Queue.Queue() #初始化队列  
    
def onsigchld(a,b):  
  '''''''收到信号后向队列中插入一个数字1'''  
  print '收到SIGUSR1信号' 
  sleep(2)  
  QCOUNT.put(1) #向队列中写入  
  
def exithanddle(s,e): 
  raise SystemExit('收到终止命令,退出程序')  
  
signal.signal(signal.SIGUSR1,onsigchld) #绑定信号处理函数  
signal.signal(signal.SIGINT,exithanddle) #当按下Ctrl + C 终止进程 
    
while 1:  
  print '我的pid是',os.getpid()  
  print '现在队列中元素的个数是',QCOUNT.qsize()  
  sleep(2) 

''''''' 
使用多线程向另外一个进程发送信号 
'''  
import threading  
import os  
import signal  
    
def sendusr1():  
  print '发送信号' 
  #这里的进程id需要写前一个程序实际运行的pid  
  os.kill(17788, signal.SIGUSR1)  
     
WORKER = []  
    
#开启6个线程  
for i in range(1, 7):  
  threadinstance = threading.Thread(target = sendusr1)  
  WORKER.append(threadinstance)  
    
for i in WORKER:  
  i.start()  
    
for i in WORKER:  
  i.join()  
    
print '主线程完成' 

5）共享数据（Manager）

def Manager():
    return multiprocessing.SyncManager()

Barrier(parties[, action[, timeout]])

    Create a shared threading.Barrier object and return a proxy for it.

    New in version 3.3.

BoundedSemaphore([value])

    Create a shared threading.BoundedSemaphore object and return a proxy for it.

Condition([lock])

    Create a shared threading.Condition object and return a proxy for it.

    If lock is supplied then it should be a proxy for a threading.Lock or threading.RLock object.

    Changed in version 3.3: The wait_for() method was added.

Event()

    Create a shared threading.Event object and return a proxy for it.

Lock()

    Create a shared threading.Lock object and return a proxy for it.

Namespace()

    Create a shared Namespace object and return a proxy for it.

Queue([maxsize])

    Create a shared queue.Queue object and return a proxy for it.

RLock()

    Create a shared threading.RLock object and return a proxy for it.

Semaphore([value])

    Create a shared threading.Semaphore object and return a proxy for it.

Array(typecode, sequence)

    Create an array and return a proxy for it.

Value(typecode, value)

    Create an object with a writable value attribute and return a proxy for it.

dict()
dict(mapping)
dict(sequence)

    Create a shared dict object and return a proxy for it.

list()
list(sequence)

    Create a shared list object and return a proxy for it.

举例：

from multiprocessing import Manager,Process,Lock
import os
def work(d,lock):
    # with lock: #不加锁而操作共享的数据,肯定会出现数据错乱
        d['count']-=1

if __name__ == '__main__':
    lock=Lock()
    with Manager() as m:
        dic=m.dict({'count':100})
        p_l=[]
        for i in range(100):
            p=Process(target=work,args=(dic,lock))
            p_l.append(p)
            p.start()
        for p in p_l:
            p.join()
        print(dic)
        #{'count': 94}

进程之间操作共享的数据

 四、进程间 同步与互斥

　　1、Semaphore，Event，Lock，RLock，Condition

Semaphore：信号量（一次性可 设置多把锁）

class Semaphore(object):
    def __init__(self, value=1):　　#value 设置 多少把锁  默认与Lock  一样
        pass

    def acquire(self, blocking=True, timeout=None):　　　　　#获取资源  
        pass

    def release(self):         #释放资源
        pass

样例：

from multiprocessing import Process,Semaphore
import time,random

def go_wc(sem,user):
    sem.acquire()
    print('%s 占到一个茅坑' %user)
    time.sleep(random.randint(0,3)) #模拟每个人拉屎速度不一样，0代表有的人蹲下就起来了
    sem.release()

if __name__ == '__main__':
    sem=Semaphore(5)
    p_l=[]
    for i in range(13):
        p=Process(target=go_wc,args=(sem,'user%s' %i,))
        p.start()
        p_l.append(p)

    for i in p_l:
        i.join()

Event：  事件（通过设置  标志位  获取  访问权限 ）

class Event(object):
    def is_set(self):　　　　　　#判断flag  是否为True  是的话 返回True  不是 返回false
        return False

    def set(self):　　　　　　　　#使flag为Ture  然后程序会停止运行 进入运行状态  
        pass

    def clear(self):　　　　　　　　#使flag为false  然后程序会停止运行 进入阻塞状态  
        pass

    def wait(self, timeout=None):　　#插入在进程中插入一个标记（flag）  默认为 false  然后flag为false时  程序会停止运行  进入阻塞状态  
        pass

样例：

from multiprocessing import Process,Event
import time,random

def car(e,n):
    while True:
        if not e.is_set(): #Flase
            print('33[31m红灯亮33[0m，car%s等着' %n)
            e.wait()
            print('33[32m车%s 看见绿灯亮了33[0m' %n)
            time.sleep(random.randint(3,6))
            if not e.is_set():
                continue
            print('走你,car', n)
            break

def police_car(e,n):
    while True:
        if not e.is_set():
            print('33[31m红灯亮33[0m，car%s等着' % n)
            e.wait(1)
            print('灯的是%s，警车走了,car %s' %(e.is_set(),n))
            break

def traffic_lights(e,inverval):
    while True:
        time.sleep(inverval)
        if e.is_set():
            e.clear() #e.is_set() ---->False
        else:
            e.set()

if __name__ == '__main__':
    e=Event()
    # for i in range(10):
    #     p=Process(target=car,args=(e,i,))
    #     p.start()

    for i in range(5):
        p = Process(target=police_car, args=(e, i,))
        p.start()
    t=Process(target=traffic_lights,args=(e,10))
    t.start()

Lock （与linux  PV 操作类似； 容易造成死锁）

class Lock(object):
    def acquire(self, blocking=True, timeout=-1):　　　　#获取锁资源     参数：blocking   True：阻塞状态； Flase:当块参数设置为false时，方法调用不会阻塞。如果锁当前处于锁定状态，则返回False；否则将锁设置为锁定状态并返回True。  timeout：设置等
        pass

    def release(self):　　　　#释放资源
        pass

样例：

from multiprocessing import Process,Lock
import os,time
def work(lock):
    lock.acquire()
    print('%s is running' %os.getpid())
    time.sleep(2)
    print('%s is done' %os.getpid())
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    for i in range(3):
        p=Process(target=work,args=(lock,))
        p.start()

RLock（递归锁） RLock允许在同一线程中被多次acquire

class RLock(object):
    def acquire(self, blocking=True, timeout=-1):　　#获取锁资源 参数：blocking True：阻塞状态； Flase:当块参数设置为false时，方法调用不会阻塞。如果锁当前处于锁定状态，则返回False；否则将锁设置为锁定状态并返回True。 timeout：设置等
        pass

    def release(self):　　#释放资源
        pass

    def __enter__(self):
        pass

    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

举例：

def showdata(lock, i):
    with lock:
        time.sleep(2)
        print(i)


if __name__ == "__main__":
    lock = multiprocessing.RLock()  # 创建锁
    for num in range(10):
        multiprocessing.Process(target=showdata, args=(lock, num)).start()

Condition（条件变量）

class Condition(object):
    def __init__(self, lock=None):
        pass

    def acquire(self, *args):
        pass

    def release(self):
        pass

    def wait(self, timeout=None):
        pass

    def wait_for(self, predicate, timeout=None):
        pass

    def notify(self, n=1):
        pass

    def notify_all(self):
        pass