Chính xác thì Phương thức .join () của Mô-đun đa xử lý Python đang làm gì?

Tìm hiểu về Đa xử lý trong Python (từ một bài báo PMOTW ) và muốn được giải thích rõ ràng về chính xác join()phương pháp này đang làm gì.

Trong một hướng dẫn cũ từ năm 2008, nó nói rằng nếu không có lệnh p.join()gọi trong đoạn mã bên dưới, "tiến trình con sẽ không hoạt động và không kết thúc, trở thành một thây ma bạn phải giết theo cách thủ công".

from multiprocessing import Process

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

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

Tôi đã thêm một bản in PIDcũng như một bản in time.sleepđể kiểm tra và theo như tôi có thể nói, quá trình tự kết thúc:

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()

trong vòng 20 giây:

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

sau 20 giây:

947 ttys001    0:00.13 -bash

Hành vi giống nhau khi p.join()được thêm lại vào cuối tệp. Mô-đun Python trong tuần cung cấp giải thích rất dễ đọc về mô-đun ; "Để đợi cho đến khi một quá trình hoàn thành công việc và thoát ra, hãy sử dụng phương thức join ().", Nhưng có vẻ như ít nhất OS X đã làm điều đó.

Tôi cũng đang thắc mắc về tên của phương pháp. Là .join()phương pháp concatenating bất cứ điều gì ở đây? Nó có nối một quá trình với nó kết thúc không? Hay nó chỉ dùng chung một tên với .join()phương thức gốc của Python ?

Các join()phương pháp, khi được sử dụng với threadinghoặc multiprocessing, không liên quan đến str.join()- nó không thực sự concatenating bất cứ điều gì với nhau. Đúng hơn, nó chỉ có nghĩa là "đợi [luồng / quy trình] này hoàn thành". Tên joinnày được sử dụng vì multiprocessingAPI của mô-đun có nghĩa là trông giống với threadingAPI của mô-đun và threadingmô-đun sử dụng joincho Threadđối tượng của nó . Việc sử dụng thuật ngữ này joincó nghĩa là "đợi một chuỗi hoàn thành" phổ biến trên nhiều ngôn ngữ lập trình, vì vậy Python cũng đã áp dụng nó.

Bây giờ, lý do bạn thấy độ trễ 20 giây cả khi có và không có lệnh gọi đến join()là vì theo mặc định, khi tiến trình chính sẵn sàng thoát, nó sẽ ngầm gọi join()tất cả các multiprocessing.Processphiên bản đang chạy . Điều này không được nêu rõ ràng trong multiprocessingtài liệu nhưng nó được đề cập trong phần Nguyên tắc lập trình :

Cũng nên nhớ rằng các quy trình không phải daemonic sẽ tự động được tham gia.

Bạn có thể ghi đè lên hành vi này bằng cách thiết lập daemoncờ trên Processđể Truetrước khi bắt đầu quá trình này:

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

Nếu bạn làm điều đó, quy trình con sẽ bị chấm dứt ngay sau khi quy trình chính hoàn tất :

daemon

Cờ daemon của tiến trình, một giá trị Boolean. Điều này phải được đặt trước khi start () được gọi.

Giá trị ban đầu được kế thừa từ quá trình tạo.

Khi một quá trình thoát ra, nó sẽ cố gắng chấm dứt tất cả các quá trình con daemonic của nó.

Nếu không có join(), quy trình chính có thể hoàn thành trước khi quy trình con thực hiện. Tôi không chắc trong những trường hợp nào dẫn đến chủ nghĩa xác sống.

Mục đích chính join()là để đảm bảo rằng một quy trình con đã hoàn thành trước khi quy trình chính thực hiện bất cứ điều gì phụ thuộc vào công việc của quy trình con.

Từ nguyên của join()nó là ngược lại với fork, là thuật ngữ phổ biến trong hệ điều hành Unix-family để tạo các tiến trình con. Một quy trình duy nhất "chia" thành một số, sau đó "nối" lại thành một.

Tôi sẽ không giải thích chi tiết những gì joincó, nhưng đây là từ nguyên và trực giác đằng sau nó, sẽ giúp bạn nhớ ý nghĩa của nó dễ dàng hơn.

Ý tưởng là thực hiện " dĩa " vào nhiều quá trình trong đó một là bậc thầy, các công nhân còn lại (hoặc "nô lệ"). Khi các công nhân làm xong, chúng "tham gia" với tổng thể để quá trình thực thi nối tiếp có thể được tiếp tục.

Các joinphương pháp làm cho quá trình tổng thể để chờ đợi một người lao động để tham gia nó. Phương thức tốt hơn có thể được gọi là "wait", vì đó là hành vi thực tế mà nó gây ra trong master (và đó là những gì nó được gọi trong POSIX, mặc dù các luồng POSIX cũng gọi nó là "join"). Việc liên kết chỉ xảy ra khi các chủ đề hợp tác với nhau một cách hợp lý, nó không phải là điều mà chủ đề làm .

Các tên "fork" và "join" đã được sử dụng với ý nghĩa này trong đa xử lý kể từ năm 1963 .

join()được sử dụng để đợi các quy trình worker thoát ra. Người ta phải gọi close()hoặc terminate()trước khi sử dụng join().

Giống như @Russell được đề cập, tham gia giống như ngược lại với fork (sinh ra các quy trình phụ).

Để tham gia chạy, bạn phải chạy điều close()này sẽ ngăn không cho bất kỳ nhiệm vụ nào khác được gửi vào nhóm và thoát ra sau khi tất cả các nhiệm vụ hoàn thành. Ngoài ra, đang chạy terminate()sẽ chỉ thoát ra bằng cách dừng tất cả các quy trình của worker ngay lập tức.

"the child process will sit idle and not terminate, becoming a zombie you must manually kill" điều này có thể xảy ra khi quy trình chính (cha) thoát ra nhưng quy trình con vẫn đang chạy và sau khi hoàn thành, quy trình mẹ không có quy trình cha nào để trả lại trạng thái thoát của nó.

Lệnh join()gọi đảm bảo rằng các dòng mã tiếp theo của bạn không được gọi trước khi tất cả các quá trình đa xử lý được hoàn thành.

Ví dụ: nếu không có join(), mã sau sẽ gọi restart_program()ngay cả trước khi quá trình kết thúc, điều này tương tự như không đồng bộ và không phải là những gì chúng tôi muốn (bạn có thể thử):

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()

Để đợi cho đến khi một tiến trình hoàn thành công việc và thoát ra, hãy sử dụng phương thức join ().

và

Lưu ý Điều quan trọng là tham gia () quá trình sau khi kết thúc nó để cho máy móc nền có thời gian cập nhật trạng thái của đối tượng để phản ánh việc kết thúc.

Đây là một ví dụ tốt đã giúp tôi hiểu nó: tại đây

Một điều cá nhân tôi nhận thấy là quy trình chính của tôi bị tạm dừng cho đến khi đứa trẻ hoàn thành quá trình của nó bằng cách sử dụng phương thức join () đã đánh bại điểm mà tôi sử dụng multiprocessing.Process()ngay từ đầu.