Python 进程

进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

同步：

同步就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。

异步：

异步的概念和同步相对。当一个异步功能调用发出后，调用者不能立刻得到结果。当该异步功能完成后，通过状态、通知或回调来通知调用者。如果异步功能用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一种很严重的错误）。如果是使用通知的方式，效率则很高，因为异步功能几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。

阻塞：

阻塞调用是指调用结果返回之前，当前线程会被挂起（如遇到io操作）。函数只有在得到结果之后才会将阻塞的线程激活。有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。
举例：

同步调用：apply一个累计1亿次的任务，该调用会一直等待，直到任务返回结果为止，但并未阻塞住（即便是被抢走cpu的执行权限，那也是处于就绪态）
阻塞调用：当socket工作在阻塞模式的时候，如果没有数据的情况下调用recv函数，则当前线程就会被挂起，直到有数据为止。

非阻塞：

非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前也会立刻返回，同时该函数不会阻塞当前线程。

小结：

同步与异步针对的是函数/任务的调用方式：同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数（任务）完成，而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成。
阻塞与非阻塞针对的是进程或线程：阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程

multiprocessing模块

python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu_count()查看），在python中大部分情况需要使用多进程。Python提供了multiprocessing模块。

与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。

创建进程(使用Process类)

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

强调：

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

参数：

group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务，函数名
args表示调用对象的位置参数元组，单个参数时不要忘记加逗号，函数的参数
kwargs表示调用对象的字典，kwargs={}，函数的参数
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字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解）

开启进程的第一种方法：

from multiprocessing import Process
import time


def func(s):
    print(s)
    time.sleep(1)
    print('进程结束')


if __name__ == '__main__':
    p1 = Process(target=func, args=('哈哈哈',))  # 单个参数必须加逗号
    p1.start()

开启进程的第二种方法：

import time
from multiprocessing import Process


class son_process(Process):
    def __init__(self, name):  # 向子进程里传参数
        super().__init__()
        self.name = name

    def run(self):  # 必须要重写父类的run()函数，子进程进行的操作都写在这里面
        print('开始运行子进程 %s ' % self.name)
        time.sleep(1)
        print('子进程结束')


if __name__ == '__main__':
    p1 = son_process('哈哈哈')
    p1.start()  # start会自动调用run
    print('主进程')

注意：在windows系统中，使用Process()创建进程对象必须要在if __name__ == “__main __”下，由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。如果在导入时调用Process()，那么这将启动无限继承的新进程（或直到机器耗尽资源）。这是隐藏对Process()内部调用的原因，使用if __name__ == “__main __”，这个if语句中的语句将不会在导入时被调用。

僵尸进程&孤儿进程：

僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵尸进程。

孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

守护进程：

主进程创建守护进程

守护进程会在主进程代码执行结束后就终止
守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止

from multiprocessing import Process
import time


class son_process(Process):

    def __init__(self, name):  # 向子进程里传参数
        super().__init__()
        self.name = name

    def run(self):  # 必须要重写父类的run()函数，子进程进行的操作都写在这里面
        print('开始运行子进程 %s ' % self.name)
        time.sleep(1)
        print('子进程结束')


if __name__ == '__main__':
    p = son_process('哈哈哈')
    p.daemon = True  # 一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
    p.start()
    print('主进程')

同步锁（互斥锁）：

将进程上锁后，进程的运行方式相当于改为串行，降低了效率，但是保证了数据的安全。

from multiprocessing import Process, Lock
import time

lock = Lock()


class son_process(Process):

    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        lock.acquire()  # 上锁
        print('开始运行子进程 %s ' % self.name)
        lock.release()  # 释放锁
        time.sleep(1)
        lock.acquire()  # 上锁
        print('子进程结束')
        lock.release()  # 释放锁


if __name__ == '__main__':
    p = son_process('哈哈哈')
    p.start()
    print('主进程')

还有另一个锁——递归锁RLock()，作用和Lock()相同，只是RLock()可以重复上锁，必须要一对一释放锁。

队列：

进程彼此之间互相隔离，队列实现进程间通信（IPC）的一种方式。

创建队列的类:

Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

maxsize是队列中允许最大项数，省略则无大小限制。

方法:

q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
q.get_nowait():同q.get(False)
q.put_nowait():同q.put(False)
q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样\

其他方法(了解):

q.cancel_join_thread():不会在进程退出时自动连接后台线程。可以防止join_thread()方法阻塞。
q.close():关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。
q.join_thread()：连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为。

from multiprocessing import Queue

q = Queue(3)
q.put(3)
q.put(3)
q.put(3)
print(q.full())  # 满了
print(q.get())
print(q.get())
print(q.get())
print(q.empty())  # 空了

另一种队列JoinableQueue()

JoinableQueue([maxsize])：这就像是一个Queue对象，但队列允许项目的使用者通知生成者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。

maxsize是队列中允许最大项数，省略则无大小限制。
方法：

JoinableQueue的实例p除了与Queue对象相同的方法之外还具有：
q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止

管道(不推荐):

创建管道的类：

Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道

duplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。

方法：

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


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

注意：使用完毕，管道两端都要关闭

信号量：

信号量(Semaphore())也是一种锁，不过信号量在初始化时会定义一个数字n，同时最多只能n个进程访问被加锁的数据

s = Semaphore(n)

使用方法和普通锁相同

事件：

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

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

wait()：当“Flag”为True时，不会阻塞，反之则阻塞

clear()：将“Flag”设置为False

set()：将“Flag”设置为True

进程池：

当程序需要创建几百甚至几千个进程做同一件事时，手动管理这么多进程太过繁琐，这时候用进程池来管理这么多的进程就方便了。

创建进程池的类：

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

numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值
initializer：是每个工作进程启动时要执行的可调用对象，默认为None
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是可调用对象，接收输入参数。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被垃圾回收，将自动调用此函数

注：如果主进程需要等待进程池里的进程处理完之后再统一处理则不需要回调函数

posted @ 2018-09-16 16:46 Wuliwawa 阅读(70) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Wuliwawa

Python 进程

multiprocessing模块

队列：

管道(不推荐):

信号量：

事件：

进程池：

公告