Process类的方法

from multiprocessing import Process


def write_file(a, b, c, name, age):
    import time
    time.sleep(3)
    print('子进程')
# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    # 1. 开启进程

    '''
        name=None, 用来修改进程名称
        args=(), kwargs={}
    '''
    p = Process(target=write_file, name='aaaaaa', args=(1, 2, 3), kwargs={'name':'ly', 'age':19})
    # 2. 真正的开启进程
    p.start()  # 操作系统开的进程，通知操作系统开进程

    # print(p.is_alive())  # 判断进程是否还存活
    #
    # # 通知杀死进程，不会瞬间杀死
    # p.terminate()  # 杀死进程
    # import time
    # time.sleep(2)
    # print(p.is_alive())

    p.join()
    print('end')

如何查看进程号

from multiprocessing import Process
import os

def write_file(a, b, c, name, age):
    print('子进程的id号：%s' % os.getpid())
    print('父进程的id号：%s' % os.getppid())
    import time
    time.sleep(20)
# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    # 1. 开启进程

    '''
        name=None, 用来修改进程名称
        args=(), kwargs={}
    '''
    p = Process(target=write_file, name='aaaaaa', args=(1, 2, 3), kwargs={'name':'ly', 'age':19})
    # 2. 真正的开启进程
    p.start()  # 操作系统开的进程，通知操作系统开进程
    print('主进程的id号：%s' % os.getpid())
    print('主进程的父进程id号：%s' % os.getppid())
    import time
    time.sleep(10)

如何开启多个进程

from multiprocessing import Process
import os
import time
def write_file(a, b, c, name, age):
    # with open('a.txt', 'a', encoding='utf-8') as f:
    #     f.write('aaaaa\n')
    # print('子进程')

    import time
    time.sleep(1)
# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    ctime = time.time()
    ll = []
    for i in range(5):
        p = Process(target=write_file, name='aaaaaa', args=(1, 2, 3), kwargs={'name': 'ly', 'age': 19})
        # 2. 真正的开启进程
        p.start()  # 操作系统开的进程，通知操作系统开进程
        ll.append(p)

    for j in ll:
        j.join()

    print('time：' , time.time() - ctime )

进程锁

# 锁的目的就是为了保证数据安全
from multiprocessing import Process, Lock
import os
import time
def write_file(i, lock):
    # 上锁
    lock.acquire()
    print('第%s个进程进来了' % i)
    time.sleep(1)
    print('第%s个进程走了' % i)
    # 释放锁
    lock.release()

# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    lock = Lock()
    for i in range(5):
        p = Process(target=write_file, args=(i, lock))
        # 2. 真正的开启进程
        p.start()  # 操作系统开的进程，通知操作系统开进程

进程间数据隔离问题

# 进程之间的数据是隔离的，不能互相使用

from multiprocessing import Process, Lock
import os
import time
n = 100
def write_file():
    global n
    n = 200
    print('子进程中的n:', n)

# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    p = Process(target=write_file,)
    # 2. 真正的开启进程
    p.start()  # 操作系统开的进程，通知操作系统开进程
    print('主进程中的n: ', n)

Queue队列

# 队列：先进先出
# 栈：先进后出

# 链表，单链表，双链表，循环链表，
# 栈，队列，树， 二叉树，平衡树，红黑树，b+树，b-树，b树， 图

from multiprocessing import Queue

if __name__ == '__main__':
    q=Queue(3)

    # 入队列
    q.put('hello world1')
    q.put('hello world2')
    q.put('hello world3')
    # block如果放不进去，会立马报错。不会阻塞
    # q.put('hello world4', block=False)
    # q.put('hello world4', timeout=3)
    # q.put_nowait('aaaaa')

    # print(q.get())
    # print(q.get())
    # print(q.get())
    # block=True, timeout=None
    # print(q.get())
    # q.get_nowait()
    print(q.qsize())
    print(q.full())

解决进程间数据隔离问题

from multiprocessing import Process, Lock, Queue
import os
import time
n = 100
def write_file(q):
    q.put('我是子进程')

# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    q = Queue(3)
    p = Process(target=write_file, args=(q, ))
    # 2. 真正的开启进程
    p.start()  # 操作系统开的进程，通知操作系统开进程

    print('主进程: ', q.get())

生产者消费者模型

# 生产者和消费者模式能够解决绝大多数并发问题

生产者和消费者彼此之间不直接通讯

消费者不找生产者要数据

# 版本5：多生产者，少消费者
# 1. 生产者

def producer(q, food):
    # 让生产者生产10个包子
    for i in range(10):
        data = '%s生产了%s' % (i, food)
        q.put(data)


# 2. 消费者
def consumer(q):
    while True:
        data = q.get()
        print(data)
        if data is None:
            break


if __name__ == '__main__':
    q = Queue(30)
    # 生产者
    p = Process(target=producer, args=(q, '咖啡'))
    p1 = Process(target=producer, args=(q, '汉堡'))
    p2 = Process(target=producer, args=(q, '馒头'))
    p.start()
    p1.start()
    p2.start()

    # 消费者
    p4 = Process(target=consumer, args=(q,))
    p5 = Process(target=consumer, args=(q,))
    p4.start()
    p5.start()

    p.join()
    p1.join()
    p2.join()
    # 放在这不行，原因是主进程执行的速度快，里面就把None写入了队列，而消费者读取的第一个数据就是None，直接结束
    q.put(None)
    q.put(None)

 

搜索

复制