python多进程

deamon 和 join

• deamon 让线程以守护线程的形式运行 主线程不会等待子线程 主线程结束 会把子线程干掉 程序结束
• join 作用是阻塞 等待子线程结束 参数就是等待的时间

import threading
import time


def do1():
    print("do1111start")
    time.sleep(2)
    print('do1111end')


def do2():
    print("do2222start")
    time.sleep(3)
    print('do2222end')


def do3():
    print("do333start")
    time.sleep(4)
    print('do333end')


t1 = threading.Thread(target=do1)
t2 = threading.Thread(target=do2)
t3 = threading.Thread(target=do3)

t1.setDaemon(True)  # 让线程以守护线程的形式运行  主线程不会等待子线程   主线程结束 会把子线程干掉 程序结束
t2.setDaemon(True)
t3.setDaemon(True)

t1.start()
t2.start()
t3.start()

t1.join(1) # 作用是阻塞 等待子线程结束 参数就是等待的时间
t2.join(1)
t3.join(2)

print("hehehe")

多进程

# 唱歌与跳舞
import time

import multiprocessing  # 进程的包


def dance():
    while True:
        print("跳舞")
        time.sleep(1)


def song():
    while True:
        print("唱歌")
        time.sleep(1)


def main():
    """一边唱歌一边跳舞"""
    # 创建一个进程
    process_dance = multiprocessing.Process(target=dance)
    # 开启
    process_dance.start()

    # 创建一个进程
    process_song = multiprocessing.Process(target=song)
    # 开启
    process_song.start()


if __name__ == '__main__':
    main()

进程PID(进程号)

• os.getpid()获取当前进程的pid
• os.getppid()获取父进程的pid

# 唱歌与跳舞
import os
import time

import multiprocessing  # 进程的包


def dance():
    while True:
        print("跳舞", os.getpid(), '-----', os.getppid())
        time.sleep(1)


def song():
    while True:
        print("唱歌", os.getpid(), '-----', os.getppid())
        time.sleep(1)


def main():
    print("主进程", os.getpid())
    """一边唱歌一边跳舞"""
    # 创建一个进程
    process_dance = multiprocessing.Process(target=dance)
    # 开启
    process_dance.start()

    # 创建一个进程
    process_song = multiprocessing.Process(target=song)
    # 开启
    process_song.start()


if __name__ == '__main__':
    main()

进程的方法

deamon 和join和在线程里的作用效果一致

• start()：启动子进程实例（创建子进程）
• is_alive()：判断子进程是否还在活着
• join([timeout])：是否等待子进程执行结束，或等待多少秒
• terminate()：不管任务是否完成，立即终止子进程

linux杀死进程

• ps -aux|sublime 查询sublime的进程信息

kill 进程号 

如果权限不够

sudo kill -9 进程号

子进程不会共享全局变量

• 下面的代码中 子进程开启时 会复制一份全局变量num

# 定义全局变量,一个读一个写
import os
import time

import multiprocessing

num = 10


# 写数据
def write():
    global num
    for i in range(5):
        num += 1
    print("加完后的数据:", num)


# 读数据
def read():
    print("读到的数据:", num)


def main():
    """一边读一边写"""
    multiprocessing.Process(target=write).start()
    time.sleep(2)
    multiprocessing.Process(target=read).start()
    time.sleep(2)
    print('子进程结束后全局变量的值：%d' % num)


# 子进程创建 会复制主进程数据

if __name__ == '__main__':
    main()

进程的队列

• 创建 对列的时候如果传入的参数 ，比如Queue(3) ，最多可接收三条put消息

• full 判断队列是否存 满

• 如果存满了 再次put 就阻塞 等待

from multiprocessing import Queue

q = Queue(3)  # 初始化一个Queue对象，最多可接收三条put消息
q.put("消息1")
q.put("消息2")
print(q.full())  # False
q.put("消息3")
print(q.full())  # True

aaa = q.get()
print(aaa)
print(q.full())  # False

q.put("1111")
print("hehe")
# q.put("2222") # 如果队列满了 就阻塞 等待
print("haha")
# q.put("3333")

队列等待和超时

• q.qsize()获取队列数量

• block=False 当队列满的时候 不等待 直接报错

• put_nowait(‘haha’) # 作用和lock=False 一样

• q.put(“haha”, timeout=3) # timeout=3等待3秒 如果队列还是满，报错

q = Queue(4)  # 初始化一个Queue对象，最多可接收三条put消息
q.put("消息1")
q.put("消息2")
q.put("消息3")
q.put("消息3")
print(q.qsize())

q.put("haha", block=False) # block=False 当队列满的时候 不等待 直接报错
# q.put_nowait('haha')  # 作用和lock=False 一样
q.put("haha", timeout=3) # timeout=3等待3秒 如果队列还是满，报错
print("11111")

进程间通信

import multiprocessing
import time
from multiprocessing import Queue


# 创建一个进程类 存数据
class Write(multiprocessing.Process):
    def __init__(self, q):
        super().__init__()
        # 接收传入的队列
        self.q = q

    def run(self):
        for i in range(100):
            self.q.put(i)
            time.sleep(0.3)


# 创建一个进程类 取数据
class Read(multiprocessing.Process):
    q: multiprocessing.Queue

    def __init__(self, q):
        super().__init__()
        # 接收传入的队列
        self.q = q

    def run(self):
        while True:
            num = self.q.get()
            print("获取num", num)


def main():
    q = multiprocessing.Queue()
    w = Write(q)
    r = Read(q)
    w.start()
    r.start()


if __name__ == '__main__':
    main()

super().init()
# 接收传入的队列
self.q = q

def run(self):
    while True:
        num = self.q.get()
        print("获取num", num)

def main():
q = multiprocessing.Queue()
w = Write(q)
r = Read(q)
w.start()
r.start()

if name == ‘main’:
main()