วิธีการทำ .join () ของโมดูลมัลติโพรเซสเซอร์ของ Python คืออะไร

เรียนรู้เกี่ยวกับ Python Multiprocessing (จากบทความ PMOTW ) และชอบคำชี้แจงเกี่ยวกับjoin()วิธีการนี้

ในบทช่วยสอนเก่าตั้งแต่ปี 2008ระบุว่าหากไม่มีการp.join()เรียกในโค้ดด้านล่าง "กระบวนการย่อยจะไม่ได้ใช้งานและไม่ยุติกลายเป็นซอมบี้ที่คุณต้องฆ่าด้วยตนเอง"

from multiprocessing import Process

def say_hello(name='world'):
    print "Hello, %s" % name

p = Process(target=say_hello)
p.start()
p.join()

ฉันได้เพิ่มงานพิมพ์ของPIDa time.sleepเพื่อทดสอบและเท่าที่ฉันสามารถบอกได้กระบวนการนี้จะสิ้นสุดลงด้วยตัวเอง:

from multiprocessing import Process
import sys
import time

def say_hello(name='world'):
    print "Hello, %s" % name
    print 'Starting:', p.name, p.pid
    sys.stdout.flush()
    print 'Exiting :', p.name, p.pid
    sys.stdout.flush()
    time.sleep(20)

p = Process(target=say_hello)
p.start()
# no p.join()

ภายใน 20 วินาที:

936 ttys000    0:00.05 /Library/Frameworks/Python.framework/Versions/2.7/Reso
938 ttys000    0:00.00 /Library/Frameworks/Python.framework/Versions/2.7/Reso
947 ttys001    0:00.13 -bash

หลังจาก 20 วินาที:

947 ttys001    0:00.13 -bash

ลักษณะการทำงานจะเหมือนกันเมื่อp.join()เพิ่มกลับที่ท้ายไฟล์ งูหลามโมดูลของสัปดาห์มีคำอธิบายที่อ่านได้มากของโมดูล ; "ในการรอจนกว่ากระบวนการทำงานจะเสร็จสิ้นและออกจากระบบให้ใช้เมธอด join ()" แต่ดูเหมือนว่าอย่างน้อย OS X ก็ทำเช่นนั้นอยู่ดี

ฉันยังสงสัยเกี่ยวกับชื่อของวิธีการ เป็น.join()วิธีการเชื่อมโยงอะไรที่นี่? การเชื่อมต่อกับกระบวนการสิ้นสุดลงหรือไม่ หรือเพียงแค่ใช้ชื่อร่วมกับ.join()วิธีดั้งเดิมของ Python ?

join()วิธีเมื่อใช้กับthreadingหรือmultiprocessingไม่ได้เกี่ยวข้องกับstr.join()- มันไม่จริงเชื่อมโยงเข้าด้วยกันอะไร แต่หมายความว่า "รอให้ [เธรด / กระบวนการ] นี้เสร็จสมบูรณ์" ชื่อjoinนี้ใช้เนื่องจากmultiprocessingAPI ของโมดูลมีลักษณะคล้ายกับthreadingAPI ของโมดูลและthreadingโมดูลใช้joinสำหรับThreadอ็อบเจ็กต์ การใช้คำjoinเพื่อหมายถึง "รอให้เธรดเสร็จสิ้น" เป็นเรื่องปกติในหลายภาษาโปรแกรมดังนั้น Python จึงนำมาใช้เช่นกัน

ตอนนี้เหตุผลที่คุณเห็นการหน่วงเวลา 20 วินาทีทั้งที่มีและไม่มีการโทรjoin()เป็นเพราะโดยค่าเริ่มต้นเมื่อกระบวนการหลักพร้อมที่จะออกมันจะเรียกอินสแตนซ์ที่join()กำลังทำงานอยู่ทั้งหมดโดยปริยาย multiprocessing.Processสิ่งนี้ไม่ได้ระบุไว้อย่างชัดเจนในmultiprocessingเอกสารเท่าที่ควร แต่มีการกล่าวถึงในส่วนแนวทางการเขียนโปรแกรม :

โปรดจำไว้ด้วยว่ากระบวนการที่ไม่ใช่ daemonic จะถูกรวมเข้าด้วยกันโดยอัตโนมัติ

คุณสามารถลบล้างพฤติกรรมนี้ได้โดยตั้งค่าdaemonแฟล็กบนProcessto Trueก่อนเริ่มกระบวนการ:

p = Process(target=say_hello)
p.daemon = True
p.start()
# Both parent and child will exit here, since the main process has completed.

หากคุณทำเช่นนั้นกระบวนการย่อยจะสิ้นสุดลงทันทีที่กระบวนการหลักเสร็จสิ้น :

ภูต

แฟล็ก daemon ของกระบวนการซึ่งเป็นค่าบูลีน ต้องตั้งค่านี้ก่อนที่จะเรียก start ()

ค่าเริ่มต้นจะสืบทอดมาจากกระบวนการสร้าง

เมื่อกระบวนการออกจากกระบวนการจะพยายามยุติกระบวนการชายด์ daemonic ทั้งหมด

หากไม่มีjoin()กระบวนการหลักสามารถดำเนินการให้เสร็จสิ้นก่อนที่กระบวนการย่อยจะทำ ฉันไม่แน่ใจว่าภายใต้สถานการณ์ใดที่นำไปสู่การเป็นซอมบี้

จุดประสงค์หลักjoin()คือเพื่อให้แน่ใจว่ากระบวนการย่อยเสร็จสิ้นก่อนที่กระบวนการหลักจะทำอะไรก็ตามที่ขึ้นอยู่กับการทำงานของกระบวนการย่อย

นิรุกติศาสตร์join()คือมันตรงกันข้ามforkซึ่งเป็นคำทั่วไปในระบบปฏิบัติการตระกูล Unix สำหรับการสร้างกระบวนการย่อย กระบวนการเดียว "แยก" เป็นหลายรายการจากนั้น "รวม" กลับเป็นกระบวนการเดียว

ฉันจะไม่อธิบายรายละเอียดว่าjoinทำอะไรแต่นี่คือนิรุกติศาสตร์และสัญชาตญาณที่อยู่เบื้องหลังซึ่งจะช่วยให้คุณจำความหมายได้ง่ายขึ้น

แนวคิดก็คือการดำเนินการ " แยก " ไปยังกระบวนการต่างๆซึ่งกระบวนการหนึ่งเป็นหลักคนงานที่เหลือ (หรือ "ทาส") เมื่อคนงานทำงานเสร็จแล้วพวกเขาจะ "เข้าร่วม" ต้นแบบเพื่อให้การดำเนินการแบบอนุกรมสามารถกลับมาทำงานต่อได้

joinวิธีการทำให้เกิดกระบวนการหลักที่จะรอให้คนงานที่จะเข้าร่วมได้ วิธีนี้อาจเรียกว่า "รอ" ได้ดีกว่าเนื่องจากนั่นเป็นพฤติกรรมจริงที่ทำให้เกิดในต้นแบบ (และนั่นคือสิ่งที่เรียกว่าใน POSIX แม้ว่าเธรด POSIX จะเรียกมันว่า "เข้าร่วม" เช่นกัน) เข้าร่วมเกิดขึ้นเป็นผลของกระทู้ร่วมมืออย่างถูกต้องมันไม่ใช่สิ่งที่เจ้านายไม่

ชื่อ "fork" และ "join" ถูกใช้กับความหมายนี้ในการประมวลผลหลายขั้นตอนตั้งแต่ปีพ . ศ . 2506

join()ใช้เพื่อรอให้กระบวนการของผู้ปฏิบัติงานออก หนึ่งจะต้องโทรclose()หรือก่อนที่จะใช้terminate()join()

เช่นเดียวกับที่ @Russell กล่าวถึงการเข้าร่วมก็เหมือนกับสิ่งที่ตรงกันข้ามกับfork (ซึ่ง Spawns กระบวนการย่อย)

สำหรับการเข้าร่วมเพื่อรันคุณต้องรันclose()ซึ่งจะป้องกันไม่ให้ส่งงานไปยังพูลอีกต่อไปและออกเมื่องานทั้งหมดเสร็จสมบูรณ์ อีกวิธีหนึ่งคือการเรียกใช้terminate()จะออกโดยการหยุดกระบวนการของผู้ปฏิบัติงานทั้งหมดทันที

"the child process will sit idle and not terminate, becoming a zombie you must manually kill" สิ่งนี้เป็นไปได้เมื่อกระบวนการหลัก (พาเรนต์) ออกไป แต่กระบวนการลูกยังคงทำงานอยู่และเมื่อดำเนินการเสร็จสิ้นแล้วจะไม่มีกระบวนการหลักที่จะคืนสถานะการออกเป็น

การjoin()โทรช่วยให้มั่นใจได้ว่าบรรทัดถัดมาของโค้ดของคุณจะไม่ถูกเรียกก่อนที่กระบวนการมัลติโพรเซสเซอร์ทั้งหมดจะเสร็จสมบูรณ์

ตัวอย่างเช่นหากไม่มีjoin()รหัสต่อไปนี้จะเรียกrestart_program()ก่อนที่กระบวนการจะเสร็จสิ้นซึ่งคล้ายกับอะซิงโครนัสและไม่ใช่สิ่งที่เราต้องการ (คุณสามารถลอง):

num_processes = 5

for i in range(num_processes):
    p = multiprocessing.Process(target=calculate_stuff, args=(i,))
    p.start()
    processes.append(p)
for p in processes:
    p.join() # call to ensure subsequent line (e.g. restart_program) 
             # is not called until all processes finish

restart_program()

ในการรอจนกว่ากระบวนการจะเสร็จสิ้นและออกจากระบบให้ใช้เมธอด join ()

และ

หมายเหตุเป็นสิ่งสำคัญที่จะต้องเข้าร่วม () กระบวนการหลังจากยุติกระบวนการเพื่อให้เวลาเครื่องจักรพื้นหลังอัปเดตสถานะของออบเจ็กต์เพื่อให้สอดคล้องกับการสิ้นสุด

นี่เป็นตัวอย่างที่ดีที่ช่วยให้ฉันเข้าใจ: ที่นี่

สิ่งหนึ่งที่ฉันสังเกตเห็นเป็นการส่วนตัวคือกระบวนการหลักของฉันหยุดชั่วคราวจนกว่าเด็กจะเสร็จสิ้นกระบวนการโดยใช้เมธอด join () ซึ่งเอาชนะจุดที่ฉันใช้multiprocessing.Process()ในตอนแรก