Pythonプログラムは-----オープンマルチプロセス動作を処理します

Pythonプログラムは-----オープンマルチプロセス動作を処理します

我々はプロセスの多くにプロセスは、我々はすでに知っているだけであること、難しいことではありません何の関連する理論的な知識と理解を学んだ前に、実行中のプログラムは、プロセスです。すべてのプロセスが作成するために、その親です。したがって、Pythonのプログラムを実行すると、我々はプログラム中のプロセスを再作成することができ、プロセスです。複数の並行プロセスは、いくつかの点で、それはプログラムの実行速度を許可する、つまり、私たちのプログラムの複数のプロセスが存在する場合には、効果を実現することができます。私たちが学んできた知識の前に、この機能を実現するためのプロセスを作成するので、私たちは、強力なPythonモジュールの助けを必要としません。

、マルチモジュール

、マルチモジュールではなく、1回の操作でのpython、パッケージ管理プロセスを言うように注意してください。それは、ほとんどすべてのサブモジュールおよび関連プロセス含み、このパッケージでは、複数の多機能な意味から取ったマルチと呼ばれています。一部作成プロセス、プロセス同期部、プロセス、プロセスの共有間のデータプール部：非常に多くのサブモジュールので、分類を容易にするために覚えている、私のこの部分は4つのに大別します。

二、プロセスモジュールをマルチ

プロセス・モジュールは、このモジュールによって、作成のモジュール工程である、あなたは、作成プロセスを完了することができます。

Process([group [, target [, name [, args [, kwargs]]]]])、サブプロセス・タスク（まだ開始していない）を示す、オブジェクトのクラスがインスタンス化されることによって得られました

彼は強調しました：

1. あなたは、パラメータを指定するキーワードの方法を使用する必要があります
2. 伝達関数パラメータの目標位置を指定した引数は、タプルの形態である、コンマが存在しなければなりません

パラメータ説明：

• グループパラメータが使用されていない、値は常にNoneです
• ターゲットは、タスクをあるコールターゲットは、子プロセスが実行されることを示しています
• 引数パラメータは、オブジェクトを呼び出すタプルの位置を示し、args=(1,2,'egon',)
• kwargsからは、コール・オブジェクトディクショナリことを示していますkwargs={'name':'egon','age':18}
• 名前は、子プロセスの名前です。

3.1メソッドの紹介

• p.start()：）（プロセスを起動し、子プロセスのp.runを呼び出します
• p.run()：操作の方法、処理が開始されると、それは指定されたターゲットを呼び出すための関数である、我々この方法でのカスタムクラスが達成されなければなりません
• p.terminate()：P pは、子プロセスを作成した場合、子プロセスがゾンビプロセスになるために、任意の清掃作業を行わないであろう、プロセスを強制終了する、この方法は、このような状況を、特別な注意が必要です。pが、その後も、保存した場合はロックがデッドロックにつながる、解放されることはありません
• p.is_alive()：pがまだ実行されているとTrueを返すされている場合
• p.join([timeout])：Pメインスレッドが終了するのを待つ（ストレス：状態は、他のメインスレッドであり、そしてpは動作状態にあります）。タイムアウトは、タイムアウトがp.joinが開いてプロセスを開始し、ライブ実行オープンなプロセスに参加することはできませんライブに参加することができ、ことを強調しなければならないオプションです。

3.2はじめプロパティ

• p.daemon：Trueに設定されている場合、デフォルト値は、Falseで、Pの代表は、親プロセスpの終了が、またpは終了するバックグラウンドでデーモンを実行であり、真の設定した後、pは、独自の新しいプロセスを作成することはできません必要がありますでp.start()設定する前に
• p.nameプロセスの名称：
• p.pid：PIDプロセス
• p.exitcode：ランタイムなしの処理は、-N場合、（理解する）信号の終了を表すN
• p.authkey：によってアイデンティティの検証プロセスのキーは、デフォルトのos.urandom()32文字のランダムに生成された文字列。キーの目的は、通信に関わる根本的なプロセス間のネットワーク接続のセキュリティを提供するものである場合にのみ、同じ認証キーを使用して、（理解する）このタイプの接続を成功するには

ウィンドウ内の3.3を使用するプロセスカートリッジノート

何のフォーク（Linuxオペレーティングシステムのためのメカニズムを作成するプロセス）がないので、子プロセスを作成するときに、Windowsのオペレーティングシステムでは、自動的にそれを起動するには、このファイルをインポートしますが、彼らは、ファイル全体のインポートで実行するとき。だから、直接ファイルに記述された場合、プロセスは、（）子プロセス無限再帰エラーを作成します。一部使用の子プロセスを作成する必要がありif __name__ =='__main__'、保護されたかを決定するためにインポート時、それは再帰的に実行されません。

第四に、プロセスモジュールを使用してプロセスを作成します

、子プロセスをオープンする方法とPythonのプロセスの同時効果を開始します。

4.1方法のpythonで子プロセスを作成します

import time
from multiprocessing import Process

def f(name):
    print('hello', name)
    print('我是子进程')
"""
创建进程这个print语句会执行两次, 原因是创建进程首先执行了当前程序的代码，则会执行一次
接着创建进程就是复制了一份代码，在子进程中还会在执行一次，所以就会执行打印两次
""" 
print('进程测试')

if __name__ == '__main__':
    # args表示传递的参数
    p = Process(target=f, args=('bob',))
    p.start()
    time.sleep(1)
    print('执行主进程的内容了')

pythonで子プロセスを作成する4.2第二の方法

from multiprocessing import Process
import time
class Task(Process):
    def __init__(self, name):
        # self.name = name   # 这样赋值添加属性,在super（）__init__时候有重新初始化了,所以要在init下面修改值

        super().__init__()
        self.name = name

    def run(self):
        print(f"子进程的名称{self.name}")
        time.sleep(0.03)
        print("子进程结束")

if __name__ == '__main__':
    p = Task('randy')

    p.start()  # 想操作系统， 发送开启子进程的请求
    print("主进程")

4.3 Pythonの中性子メモリプロセスと主要プロセスが孤立しています

from multiprocessing import Process
import time

x = 10

def task():
    global x
    x = 100
    print(f"子进程中的x: {x}")

if __name__ == '__main__':

    p = Process(target=task)
    p.start()
    time.sleep(0.5)
    print(f"全局x的值： {x}")

4.4方法に参加

from multiprocessing import Process
import time
def task(x):
    print(f"{x}进程开始")

    time.sleep(3)
    print(f"{x}进程结束")


"""
创建进程这个print语句会执行两次, 原因是创建进程首先执行了当前程序的代码，则会执行一次
接着创建进程就是复制了一份代码，在子进程中还会在执行一次，所以就会执行打印两次
""" 
print('进程测试')

if __name__ == '__main__':

    p1 = Process(target=task, args=(1, ))
    p1.start()
    # join会阻塞住主进程在等待子进程结束，然后在执行join下面的代码（内部会调用wait）
    p1.join() 
    print("主进程")
    # p1 = Process(target=task, args=(1, ))
    # p1.start()
    # p2 = Process(target=task, args=(2, ))
    # p2.start()
    # p1.join()
    # p2.join()

以上の4.5処理時間の統計に参加

# 实现并行
from multiprocessing import Process
import time
def task(x):
    print(f"{x}进程开始")

    time.sleep(x)
    print(f"{x}进程结束")


"""
创建进程这个print语句会执行两次, 原因是创建进程首先执行了当前程序的代码，则会执行一次
接着创建进程就是复制了一份代码，在子进程中还会在执行一次，所以就会执行打印两次
""" 
print('进程测试')

if __name__ == '__main__':

    p1 = Process(target=task, args=(1, ))
    
    p2 = Process(target=task, args=(2, ))
    
    p3 = Process(target=task, args=(3, ))

    # 开始时间
    start = time.time()
    p1.start()
    p2.start()
    p3.start()

    # join会阻塞住主进程在等待子进程结束，然后在执行join下面的代码（内部会调用wait）
    p1.join()
    p2.join()
    p3.join()

    end = time.time()

    """
    程序运行的时间为3s多，主要是因为创建的三个子进程会同时启动
    会以时间最长的进程为基准，
    """
    print("程序运行时间%s" %(end-start))



# 实现串行
from multiprocessing import Process
import time
def task(x):
    print(f"{x}进程开始")

    time.sleep(x)
    print(f"{x}进程结束")


"""
创建进程这个print语句会执行两次, 原因是创建进程首先执行了当前程序的代码，则会执行一次
接着创建进程就是复制了一份代码，在子进程中还会在执行一次，所以就会执行打印两次
""" 
print('进程测试')

if __name__ == '__main__':

    p1 = Process(target=task, args=(1, ))   
    p2 = Process(target=task, args=(2, ))   
    p3 = Process(target=task, args=(3, ))

    # 开始时间
    start = time.time()
    # 实现串行，线程会一个一个的执行线程，一个线程执行完之后才会执行下一个线程
    p1.start()
    p1.join()

    p2.start()
    p2.join()

    p3.start()
    p3.join()

    end = time.time()

    """
    程序运行的时间为6s多，主要是因为创建的三个子进程会同时启动
    会以时间最长的进程为基准，
    """
    print("程序运行时间%s" %(end-start))

同時に実行して4.6複数のプロセス

from multiprocessing import Process
import time
def task(x):
    print(f"{x}进程开始")

    time.sleep(x)
    print(f"{x}进程结束")

print('进程测试')

if __name__ == '__main__':
    start = time.time()
    p_list = []
    # 创建并启动线程
    for i in range(1,5):
        p = Process(target=task, args=(i, ))
        p.start()
        p_list.append(p)

    # 使用join方法
    for p in p_list:
        p.join()
    end = time.time()
    print("程序运行时间%s" %(end-start))

4.7メインと子のプロセスIDを確認してください

from multiprocessing import Process,current_process
import time
import os
def task():
    print("进程开始")
    time.sleep(0.2)
    # 在子进程查看自己的pid
    print(f'在子进程中查看自己的pid: {current_process().pid}')
    # 在子进程中查看父进程pid
    print(f'在子进程中查看父进程pid: {os.getppid()}')
    print("进程结束")
if __name__ == '__main__':
    p = Process(target=task)
    p.start()

    print(f"在主进程中查看子进程的pid：{p.pid}")
    print(f'主进程的pid: {os.getpid()}')

    print(f'主进程中父进程pid: {os.getppid()}')

    """
    在window中的进程创建查看pid号他的顺序是从小到大排序,主线程pid大于子线程的pid
    os.getpid() 获取当前进程的pid
    os.getppid() 获取当前进程的父进程
    子进程对象.pid 获取当前进程的子进程的pid    
    """

高度な、同時に実行されている複数のプロセス（子プロセスの実行順序は、起動シーケンスに従って決定されていないことに注意してください）

4.8プロセス一般的に使用されるプロパティ

from multiprocessing import Process,current_process
import time
import os
def task():
    print("进程开始")

    time.sleep(0.2)

    # 在子进程查看自己的pid
    print(f'在子进程中查看自己的pid: {current_process().pid}')
    
    print("进程结束")
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    # 1 查看进程的名称
    print(p.name)
    # 2 判断进程是否还存在
    print(p.is_alive())
    time.sleep(3)
    print(p.is_alive())

    # 3 告诉操作系统结束之后关闭进程
    p2 = Process(target=task)
    p2.start()
    p2.terminate()

    print("terminate: ", p2.is_alive())
    p2.join()
    print("terminate: ", p2.is_alive())

V.デーモン

主要プロセスの終わりで終了します。

マスターデーモン・プロセスを作成します。

　　まず：デーモンは、メインプロセスのコード実行の終了後に終了します

　　第二：デーモンはもはや子プロセスを回すことはできません以内、それ以外の場合は、例外がスローされます：AssertionError: daemonic processes are not allowed to have children

注：プロセスは互いに独立している間、メイン処理コードの端部は、デーモン終了、実行します。

5.1デーモンを起動します

import os
import time
from multiprocessing import Process

class Myprocess(Process):
    def __init__(self,person):
        super().__init__()
        self.person = person
    def run(self):
        print(os.getpid(),self.name)
        print('%s正在和女主播聊天' %self.person)


p=Myprocess('哪吒')
p.daemon=True # 一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
p.start()
time.sleep(10)  # 在sleep时查看进程id对应的进程ps -ef|grep id
print('主')

5.2メイン処理コード実行デーモン即時端を終了します

from multiprocessing import Process

def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")


p1=Process(target=foo)
p2=Process(target=bar)

p1.daemon=True
p1.start()
p2.start()
time.sleep(0.1)
print("main-------")  # 打印该行则主进程代码结束,则守护进程p1应该被终止.#可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止

六、同時インスタンスチャットソケット

6.1を使用するマルチプロセスは、新しいソケット-server側チャットによって複雑になります

from socket import *
from multiprocessing import Process

server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind(('127.0.0.1',8080))
server.listen(5)

def talk(conn,client_addr):
    while True:
        try:
            # 注意在这里不能使用input进行交互信息，因为是在子进程中输入的，所以你输入不对
            msg=conn.recv(1024)
            if not msg:break
            conn.send(msg.upper())
        except Exception:
            break

if __name__ == '__main__': # windows下start进程一定要写到这下面
    while True:
        conn,client_addr=server.accept()
        p=Process(target=talk,args=(conn,client_addr))
        p.start()

6.1を使用するマルチプロセスは-client最後チャット新しいソケットによって複雑になります

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))


while True:
    msg=input('>>: ').strip()
    if not msg:continue

    client.send(msg.encode('utf-8'))
    msg=client.recv(1024)
    print(msg.decode('utf-8'))