より基本的なコンテンツを処理

1. 2つの方法でマルチプロセスを作成します。

1.1モード（機能）

# 方式一
from multiprocessing import Process
import time

def test(name):
    print(f"{name}的子进程开始...")
    time.sleep(3)
    print("子进程结束...")
if __name__ == '__main__':
    p = Process(target=test,args=("xc",)) # 要用元组哦
    p.start()
    # time.sleep(3)
    print("主进程")

1.2第二の方法（複数可）

# 方式二
from multiprocessing import Process
import time

class My(Process):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print(f"{self.name}的子进程开始...")
        time.sleep(3)
        print("子进程结束...")
if __name__ == '__main__':
    p = My('xc')
    p.start()
    print("xc的主进程")

2.孤立とゾンビプロセス

• 孤児プロセスは：それはゾンビプロセスになり、占有PID番号になるので、実際には、実装の主な後継者が終了、子プロセスは、行われていないので、initメソッドをリサイクルされます
• ゾンビプロセスは：実際には、オーバーランニング後の子プロセスは、彼が完了するまで、真の実行ではなく、メインプログラムの実行が終わった後に自動的に復元され、pidは最も重要な情報、ゾンビプロセスであるいくつかの情報を、保持します

3.pid、プロセスID

from multiprocessing import Process
import time
import os

class My(Process):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print(f"{self.name}的子进程开始...")
        print(self.pid)
        print(os.getpid())
        print(os.getppid())
        time.sleep(3)
        print("子进程结束...")
if __name__ == '__main__':
    p = My('xc')
    print(os.getpid())
    p.start()
    print("xc的主进程")

"""
打印结果:
    11200
    xc的主进程
    xc的子进程开始...
    6664
    6664
    11200
    子进程结束...
"""

• 現在のプロセスのPID GETPID得ることであるPID番号osモジュールを、使用するプロセスを取得するには、上記のデータとGETPID getppid方法の我々の理解を通じ、およびPPIDは親プロセスのPIDを取得することです
• もちろん、このビューには、道のPIDを超えています

メソッドに参加4.Process

• メインプログラムの実行をブロックし、メインプロセスで完了するまで実行され、子、コードの実行を待ち

from multiprocessing import Process
import time
def foo():
    print("程序开始...")
    time.sleep(3)
    print("程序结束...")

if __name__ == '__main__':
    p = Process(target=foo)
    p1 = Process(target=foo)
    p2 = Process(target=foo)
    start = time.time()
    p.start()
    p1.start()
    p2.start()
    p.join()     # 会阻塞主程序的运行
    p1.join()
    p2.join()
    end = time.time()
    print("主程序结束...")
    print(start-end)
# 打印结果:
    # 程序开始...
    # 程序结束...
    # 程序开始...
    # 程序开始...
    # 程序结束...
    # 程序结束...
    # 主程序结束...
    # -3.150564193725586
# 如果表示形式为以上的AAABBB形式,那么所需的时间为3s以上,说明这种写法是主程序等待所有都在运行的子程序执行完

###################################################################################################

from multiprocessing import Process
import time
def foo():
    print("程序开始...")
    time.sleep(3)
    print("程序结束...")

if __name__ == '__main__':
    p = Process(target=foo)
    p1 = Process(target=foo)
    p2 = Process(target=foo)
    start = time.time()
    p.start()
    p.join()  # 会阻塞主程序的运行
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    print("主程序结束...")
    end = time.time()
    print(start-end)
# 打印结果：
    # 程序开始...
    # 程序结束...
    # 程序开始...
    # 程序结束...
    # 程序开始...
    # 程序结束...
    # 主程序结束...
    # -9.349010705947876
# 根据上面的内容来看，如果按照ABABAB执行，就会出现子程序等其他子程序执行完再执行，就会叠加时间，就是一个串行的进程了

名前とis_alive方法5.Process

• 名前：子供の名前を確認してください（この名前のように、プロセス-1）
• is_alive：それはTrueを返し終わらない場合は、戻り値がブール型で、子プロセスが終了したかどうかを確認、終了に時間がかかるので、短い時間のモジュールを使用するなど、または終了を待っているの参加方法を使用します、最後はFalseを返します

from multiprocessing import Process
import time

def foo():
    print("进程开始...")
    time.sleep(3)
    print("进程结束...")

if __name__ == '__main__':
    p = Process(target=foo)
    # print(p.is_alive())
    p.start()
    print(p.name)
    print(p.is_alive())
    time.sleep(5)
    print("主程序结束...")
    print(p.is_alive())

# 自己试验下,情况就是name这个属性对应着创建线程的一个代号,它是往下迭代的例如:Process-1,Process-2这样迭代

# 关于is_alive则是表示子程序有没有结束,主要是看子程序有没有运行完,可以使用time模块测试

6.Process的ターミナル

• （直接終了しない、オペレーティングシステムに信号であり、スタートと同様に）子プロセスの終了を強制

from multiprocessing import Process
import time

def foo():
    print("进程开始...")
    time.sleep(3)
    print("进程结束...")

if __name__ == '__main__':
    p = Process(target=foo)
    p.start()
    print(p.is_alive())
    p.terminate()  # 强制结束子进程
    p.join() # 我们必须在这里使用join,等待进程结束,那就有人问了,你等他结束了is_alive肯定是Flase呀,但是我们的注意点是子程序没有打印数据
    print(p.is_alive())
    print("主进程结束...")

# 对于Process中的terminate的使用也和start一样,他只是去给操作系统发送了关闭子进程的信号,并不是直接结束

7.デーモン

• オブジェクト名で忠実なプロセスデーモンを定義するための.daemon = Trueの方法。

from multiprocessing import Process
import time
"""
守护进程
守护 --> 伴随
本质上也是一个子进程
主进程的代码执行完毕守护进程直接结束,但是此时主进程可能没有结束
"""
def foo():
    print("守护进程开始...")
    time.sleep(3)
    print("守护进程结束...")

if __name__ == '__main__':
    p = Process(target=foo)
    p.daemon = True # 这个就是把创建的子进程定义为守护进程,默认值应该是Flase
    p.start()
    # p.join()
    time.sleep(2)
    print("主进程结束...") # 也就是说主进程结束了,子进程就自动释放了,就是不会运行了

# 总结就是daemon这个方法把创建的子进程定义为守护进程,所谓的守护进程就是:主进程结束了,子进程也就是守护进程结束了
# 如果主进程没结束,子进程也就是守护进程便会像普通进程一样从有到无,从出现到离开
# 普通的子进程是不会管主进程的死活的,大不了变成孤儿进程继续运行,反正会有init方法回收