terminate()
强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self, processname):
        Process.__init__(self, name=processname)

    def run(self):
        print('%s运行结束'%self.name)

p1=MyProcess('子进程1')
p1.start()
p1.terminate()       #关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
print(p1.is_alive()) #结果为True
print('开始')
print(p1.is_alive()) #结果为False

执行以上程序会输出如下结果：

1
2
3

True
开始
False

进程同步(锁)

进程直接的内存空间是隔离的，不共享数据。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from multiprocessing import Process
n=100
def work():
    global n
    n=0
    print('子进程内: ',n)

if __name__ == '__main__':
    p=Process(target=work)
    p.start()
    print('主进程内: ',n)

执行以上程序会输出如下结果：

1
2

主进程内:  100
子进程内:  0

虽然进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理 进程锁multiprocessing.Lock()

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import multiprocessing
import sys
def worker(lock, f):
    lock.acquire()
    fs = open(f, 'a+')
    n = 100
    while n > 1:
        fs.write("The number is \n")
        n -= 1
    fs.close()
    lock.release()

if __name__ == "__main__":
    lock = multiprocessing.Lock()
    f = "file.txt"
    p1 = multiprocessing.Process(target=worker, args=(lock, f))
    p2 = multiprocessing.Process(target=worker, args=(lock, f))
    p1.start()
    p2.start()

加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的数据）
2.需要自己加锁处理
因此我们最好找寻一种解决方案能够兼顾：1、效率高（多个进程共享一块内存的数据）2、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。 1 队列和管道都是将数据存放于内存中 2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。 ​

队列Queue

构造函数
Queue([maxsize]): maxsize:队列中允许最大项数，省略则无大小限制。 创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。底层就是以管道和锁定的方式实现。

方法介绍：
put(obj[, block[, timeout]])
obj:插入的数据对象
block:可选参数，默认是True。
timeout:可选参数，默认是None。

将obj放入队列。如果block为True（默认值），timeout为None（默认值），则根据需要阻止，直到可用插槽可用。如果timeout为正数，则最多会阻塞timeout制定的秒数。如果在此时间内没有可用插槽，会抛出queue.Full异常。否则（block为false），如果空闲插槽立即可用，则将项目放入队列，否则会抛出queue.Full异常（在这种情况下，timeout将被忽略）。

put_nowait(obj):
相当于q.put(obj,False)

get([block[, timeout]])
block:可选参数，默认是True。
timeout:可选参数，默认是None。
从队列中移除并返回移除的项目。如果block为True（默认值），timeout为None（默认值），则根据需要阻止，直到有数据。如果timeout为正数，则最多会阻塞timeout制定的秒数。如果在该时间内没有可用数据项，会抛出queue.Empty异常。否则（block为false），如果有数据项立即可用，则返回该项，否则引发queue.empty异常（在这种情况下，timeout将被忽略）。

get_nowait():
相当于q.getFalse)

empty():
队列为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。

full()：
调用此方法时队列已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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()) #空了

执行以上程序会输出如下结果：

1
2
3
4
5

True
3
3
3
True

qsize():
返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样。

join_thread()：
连接队列的后台线程。此方法只能用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为

cancel_join_thread():
不会在进程退出时自动连接后台线程。可以防止join_thread()方法阻塞。

close():
关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。

管道Pipe

构造函数：
Pipe([duplex]):
dumplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。 在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道。

主要方法：
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异常。

基于管道实现进程间通信（与队列的方式是类似的，队列就是管道加锁实现的）

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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('主进程')

执行以上程序会输出如下结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

c1 收到包子:0
c1 收到包子:1
c1 收到包子:2
c1 收到包子:3
c1 收到包子:4
c1 收到包子:5
c1 收到包子:6
c1 收到包子:7
c1 收到包子:8
c1 收到包子:9
主进程

转载请注明本网址。