Hướng dẫn settimeout equivalent in python - settimeout tương đương trong python
Trong thực tế, một bộ đếm thời gian có lẽ là cách đơn giản nhất để làm những gì bạn muốn. Show
Mã này sẽ làm như sau:
===
=== Mã trên rất có thể sẽ giải quyết vấn đề của bạn. Nhưng mà! Có nhiều cách khác, không sử dụng đa luồng. Nó hoạt động giống như JavaScript, được một luồng đơn. Đối với phiên bản duy nhất này, tất cả những gì bạn cần làm là lưu trữ chức năng và các đối số của nó trong một đối tượng, cùng với thời gian mà chức năng nên được chạy. Khi bạn có đối tượng chứa lệnh gọi chức năng và thời gian chờ, chỉ cần kiểm tra định kỳ xem chức năng có sẵn sàng thực thi không. Cách đúng đắn để làm điều này là bằng cách thực hiện hàng đợi ưu tiên để lưu trữ tất cả các chức năng chúng tôi muốn chạy trong tương lai, như trong mã bên dưới. Giống như trong JavaScript, cách tiếp cận này không đảm bảo rằng chức năng sẽ được chạy chính xác đúng hạn. Một chức năng mất một thời gian rất dài để chạy sẽ trì hoãn các chức năng sau khi nó. Nhưng nó đảm bảo rằng một chức năng sẽ được chạy không sớm hơn thời gian chờ của nó. Mã này sẽ làm như sau:
===
=== Mã trên rất có thể sẽ giải quyết vấn đề của bạn. Mã nguồn: lib/đa xử lý/ Lib/multiprocessing/ Tính khả dụng: Không phải emscripten, không phải wasi.: not Emscripten, not WASI. Mô -đun này không hoạt động hoặc không có sẵn trên các nền tảng Webassugging import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()6 và import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()7. Xem các nền tảng Webassugging để biết thêm thông tin.WebAssembly platforms for more information. Giới thiệu¶import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 là một gói hỗ trợ các quy trình sinh sản sử dụng API tương tự như mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9. Gói import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 cung cấp cả đồng thời địa phương và từ xa, bước hiệu quả là khóa thông dịch toàn cầu bằng cách sử dụng các quy trình phụ thay vì các luồng. Do đó, mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 cho phép lập trình viên tận dụng đầy đủ nhiều bộ xử lý trên một máy nhất định. Nó chạy trên cả UNIX và Windows.Global Interpreter Lock by using subprocesses instead of threads. Due to this, the import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 module allows the programmer to fully leverage multiple processors on a given machine. It runs on both Unix and Windows. Mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 cũng giới thiệu API không có chất tương tự trong mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9. Một ví dụ điển hình của điều này là đối tượng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4 cung cấp một phương tiện thuận tiện để song song hóa việc thực hiện một hàm trên nhiều giá trị đầu vào, phân phối dữ liệu đầu vào trên các quy trình (song song dữ liệu). Ví dụ sau đây cho thấy thực tiễn phổ biến trong việc xác định các chức năng như vậy trong một mô -đun để các quá trình con có thể nhập thành công mô -đun đó. Ví dụ cơ bản này về sự song song dữ liệu bằng cách sử dụng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4, from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3])) sẽ in ra đầu ra tiêu chuẩn Xem thêm import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()6 cung cấp giao diện cấp cao hơn để đẩy các tác vụ đến một quy trình nền mà không chặn thực hiện quá trình gọi. So với việc sử dụng giao diện import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4 trực tiếp, API import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 dễ dàng hơn cho phép gửi công việc vào nhóm quy trình cơ bản được tách ra khỏi chờ kết quả. Lớp import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join() 9Trong import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8, các quá trình được sinh ra bằng cách tạo đối tượng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 và sau đó gọi phương thức from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()2 của nó. import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 theo API của from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()4. Một ví dụ tầm thường về chương trình đa xử lý là from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() Để hiển thị các ID quy trình cá nhân có liên quan, đây là một ví dụ mở rộng: from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join() Để biết giải thích tại sao phần from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()5 là cần thiết, hãy xem Hướng dẫn lập trình.Programming guidelines. Bối cảnh và phương pháp bắt đầuTùy thuộc vào nền tảng, import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 hỗ trợ ba cách để bắt đầu một quá trình. Các phương pháp bắt đầu này là
Đã thay đổi trong phiên bản 3.8: Trên macOS, phương thức bắt đầu sinh sản hiện là mặc định. Phương pháp bắt đầu ngã ba nên được coi là không an toàn vì nó có thể dẫn đến các sự cố của quá trình phụ. Xem BPO-33725.On macOS, the spawn start method is now the default. The fork start method should be considered unsafe as it can lead to crashes of the subprocess. See bpo-33725. Đã thay đổi trong phiên bản 3.4: Spawn được thêm vào tất cả các nền tảng Unix và Forkerver được thêm vào cho một số nền tảng Unix. Các quy trình con không còn thừa kế tất cả các tay cầm di truyền của cha mẹ trên Windows.spawn added on all Unix platforms, and forkserver added for some Unix platforms. Child processes no longer inherit all of the parents inheritable handles on Windows. Trên UNIX sử dụng các phương thức bắt đầu Spawn hoặc Forkerver cũng sẽ bắt đầu quy trình Trình theo dõi tài nguyên theo dõi các tài nguyên hệ thống được đặt tên không liên kết (như Semaphores hoặc from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()0 đối tượng) được tạo bởi các quy trình của chương trình. Khi tất cả các quy trình đã thoát khỏi Trình theo dõi tài nguyên không liên kết bất kỳ đối tượng được theo dõi còn lại nào. Thông thường không nên có, nhưng nếu một quá trình bị giết bởi tín hiệu thì có thể có một số tài nguyên bị rò rỉ của người Viking. . Để chọn phương thức bắt đầu, bạn sử dụng from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()1 trong mệnh đề from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()5 của mô -đun chính. Ví dụ: import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join() from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()1 không nên được sử dụng nhiều hơn một lần trong chương trình. Ngoài ra, bạn có thể sử dụng from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()4 để có được một đối tượng ngữ cảnh. Các đối tượng ngữ cảnh có cùng API với mô -đun đa xử lý và cho phép người ta sử dụng nhiều phương thức bắt đầu trong cùng một chương trình. import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join() Lưu ý rằng các đối tượng liên quan đến một bối cảnh có thể không tương thích với các quy trình cho một bối cảnh khác. Cụ thể, các khóa được tạo bằng bối cảnh ngã ba không thể được chuyển cho các quy trình bắt đầu sử dụng các phương thức bắt đầu sinh sản hoặc Forkerver. Một thư viện muốn sử dụng một phương thức bắt đầu cụ thể có lẽ nên sử dụng from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()4 để tránh can thiệp vào việc lựa chọn người dùng thư viện. Cảnh báo Các phương thức bắt đầu from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6 và from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7 hiện không thể được sử dụng với các tệp thực thi của Frozen Frozen (tức là, các nhị phân được sản xuất bởi các gói như Pyinstaller và CX_Freeze) trên Unix. Phương pháp bắt đầu from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8 không hoạt động.PyInstaller and cx_Freeze) on Unix. The from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8 start method does work. Trao đổi đối tượng giữa các quá trìnhimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 hỗ trợ hai loại kênh giao tiếp giữa các quy trình: Hàng đợi
Ống
Đồng bộ hóa giữa các quá trìnhimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 chứa các chất tương đương của tất cả các nguyên thủy đồng bộ hóa từ import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9. Ví dụ, người ta có thể sử dụng khóa để đảm bảo rằng chỉ có một quy trình in ra đầu ra tiêu chuẩn tại một thời điểm: from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start() Nếu không sử dụng đầu ra khóa từ các quy trình khác nhau có trách nhiệm để có được tất cả trộn lẫn. Chia sẻ trạng thái giữa các quy trìnhNhư đã đề cập ở trên, khi thực hiện lập trình đồng thời, tốt nhất là nên tránh sử dụng trạng thái chia sẻ càng nhiều càng tốt. Điều này đặc biệt đúng khi sử dụng nhiều quy trình. Tuy nhiên, nếu bạn thực sự cần sử dụng một số dữ liệu được chia sẻ thì import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 cung cấp một vài cách để làm như vậy. Bộ nhớ chia sẻ
Quá trình máy chủ
Để linh hoạt hơn trong việc sử dụng bộ nhớ chia sẻ, người ta có thể sử dụng mô -đun ____108, hỗ trợ việc tạo các đối tượng CTYPES tùy ý được phân bổ từ bộ nhớ chia sẻ.Quá trình máy chủ Một đối tượng Trình quản lý được trả về bởi 09 kiểm soát một quy trình máy chủ giữ các đối tượng Python và cho phép các quy trình khác thao túng chúng bằng các proxy. 4Một người quản lý được trả lại bởi 09 sẽ hỗ trợ các loại 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0, from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()9. Ví dụ, Trình quản lý quy trình máy chủ linh hoạt hơn so với sử dụng các đối tượng bộ nhớ được chia sẻ vì chúng có thể được tạo để hỗ trợ các loại đối tượng tùy ý. Ngoài ra, một người quản lý duy nhất có thể được chia sẻ bởi các quy trình trên các máy tính khác nhau qua mạng. Tuy nhiên, chúng chậm hơn so với sử dụng bộ nhớ chia sẻ. Sử dụng một nhóm công nhânProgramming guidelines however it is worth pointing out here. This means that some examples, such as the 26 examples will not work in the interactive interpreter. For example: 5Lớp import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4 đại diện cho một nhóm các quy trình công nhân. Nó có các phương pháp cho phép các nhiệm vụ được giảm tải cho các quy trình của công nhân theo một vài cách khác nhau. Ví dụ:Lưu ý rằng các phương pháp của một nhóm chỉ nên được sử dụng bởi quy trình đã tạo ra nó. Ghi chúChức năng trong gói này yêu cầu mô -đun 25 có thể nhập bởi trẻ em. Điều này được đề cập trong các hướng dẫn lập trình tuy nhiên nó đáng để chỉ ra ở đây. Điều này có nghĩa là một số ví dụ, chẳng hạn như các ví dụ 26 sẽ không hoạt động trong trình thông dịch tương tác. Ví dụ:multiprocessing.Process(group=None,
target=None, name=None, args=(), kwargs={}, *,
daemon=None)¶. Tài liệu tham khảo¶ Gói import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 chủ yếu sao chép API của mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9. import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 và ngoại lệ classMultipRocessing.process (nhóm = none, target = none, name = none, args = (), kwargs = {}, *, daemon = none) ¶Added the daemon argument. Các đối tượng quy trình đại diện cho hoạt động được chạy trong một quy trình riêng biệt. Lớpimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 có tương đương với tất cả các phương pháp của from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()4.()¶ Trình xây dựng phải luôn được gọi với các đối số từ khóa. Nhóm phải luôn luôn là 32; Nó chỉ tồn tại để tương thích với from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()4. Mục tiêu là đối tượng có thể gọi được được gọi bằng phương thức from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()7. Nó mặc định là 32, có nghĩa là không có gì được gọi. Tên là tên quy trình (xem 36 để biết thêm chi tiết). args là tuple đối số cho việc gọi mục tiêu. KWARGS là một từ điển của các đối số từ khóa cho việc gọi mục tiêu. Nếu được cung cấp, đối số daemon chỉ từ khóa sẽ đặt cờ 37 thành 38 hoặc 39. Nếu 32 (mặc định), cờ này sẽ được kế thừa từ quá trình tạo.Theo mặc định, không có đối số nào được truyền đến mục tiêu. Đối số ARGS, mặc định là 41, có thể được sử dụng để chỉ định danh sách hoặc tuple của các đối số để chuyển đến đích.Nếu một lớp con ghi đè hàm tạo, nó phải đảm bảo rằng nó gọi hàm tạo lớp cơ sở ( 42) trước khi làm bất cứ điều gì khác cho quy trình.Example: 6 bắt đầu()¶()¶Bắt đầu hoạt động của quá trình. Điều này phải được gọi nhiều nhất một lần cho mỗi đối tượng quy trình. Nó sắp xếp cho phương thức đối tượng ____ ____77 được gọi trong một quy trình riêng biệt. tham gia ([thời gian chờ]) ¶([timeout])¶Nếu thời gian chờ đối số tùy chọn là 32 (mặc định), phương thức sẽ chặn cho đến khi quá trình có phương thức 47 được gọi là chấm dứt. Nếu thời gian chờ là một số dương, nó sẽ chặn ở hầu hết các giây thời gian chờ. Lưu ý rằng phương thức trả về 32 nếu quá trình của nó chấm dứt hoặc nếu phương thức hết thời gian. Kiểm tra quy trình 49 để xác định xem nó có bị chấm dứt không.Một quá trình có thể được tham gia nhiều lần. Một quá trình không thể tự tham gia vì điều này sẽ gây bế tắc. Đó là một lỗi để cố gắng tham gia một quy trình trước khi nó được bắt đầu. Tên¶¶Tên quy trình. Tên chỉ là một chuỗi được sử dụng cho mục đích nhận dạng. Nó không có ngữ nghĩa. Nhiều quy trình có thể được đặt cùng một tên. Tên ban đầu được đặt bởi hàm tạo. Nếu không có tên rõ ràng nào được cung cấp cho hàm tạo, một tên của mẫu ‘quy trình-N1: N2: Tiết: NK, được xây dựng, trong đó mỗi NK là con n-th của cha mẹ của nó. is_alive () ¶()¶Trả lại liệu quá trình còn sống. Một cách thô bạo, một đối tượng quá trình còn sống từ thời điểm phương thức from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()2 trả về cho đến khi quá trình con kết thúc. đại sắc lý¶ Cờ daemon của quy trình, một giá trị boolean. Điều này phải được đặt trước khi from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()2 đượ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ó cố gắng chấm dứt tất cả các quy trình con daemon của nó. Lưu ý rằng một quá trình daemon không được phép tạo ra các quy trình con. Nếu không, một quá trình daemon sẽ khiến con cái của nó mồ côi nếu nó bị chấm dứt khi quá trình cha mẹ của nó thoát ra. Ngoài ra, đây không phải là daemon hoặc dịch vụ Unix, chúng là các quy trình bình thường sẽ bị chấm dứt (và không được tham gia) nếu các quy trình không đái tháo gỡ đã thoát ra.not Unix daemons or services, they are normal processes that will be terminated (and not joined) if non-daemonic processes have exited. Ngoài API from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()4, các đối tượng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 cũng hỗ trợ các thuộc tính và phương thức sau: pid¶¶ Trả về ID quy trình. Trước khi quá trình được sinh ra, đây sẽ là 32. EXITCODE¶¶Mã thoát trẻ con. Đây sẽ là 32 nếu quá trình chưa chấm dứt.Nếu phương thức trẻ con ____ ____77 được trả về bình thường, mã thoát sẽ là 0. Nếu nó bị chấm dứt qua 57 với đối số số nguyên n, mã thoát sẽ là N.Nếu đứa trẻ bị chấm dứt do ngoại lệ không bị bắt trong from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()7, mã thoát sẽ là 1. Nếu nó bị chấm dứt bởi tín hiệu n, mã thoát sẽ là giá trị âm -n. AuthKey¶¶ Khóa xác thực quy trình (một chuỗi byte). Khi import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 được khởi tạo, quy trình chính được gán một chuỗi ngẫu nhiên bằng cách sử dụng 60.Khi một đối tượng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 được tạo, nó sẽ kế thừa khóa xác thực của quy trình cha của nó, mặc dù điều này có thể được thay đổi bằng cách đặt 62 sang chuỗi byte khác.Xem các khóa xác thực.Authentication keys. Sentinel¶¶Một tay cầm số của một đối tượng hệ thống sẽ trở thành sẵn sàng khi quá trình kết thúc. Bạn có thể sử dụng giá trị này nếu bạn muốn chờ đợi một số sự kiện ngay lập tức bằng cách sử dụng 63. Nếu không, hãy gọi 47 là đơn giản hơn.Trên Windows, đây là một hệ điều hành có thể sử dụng được với gia đình API 65 và 66. Trên Unix, đây là một bộ mô tả tệp có thể sử dụng với các nguyên thủy từ mô -đun 67.Mới trong phiên bản 3.3. chấm dứt () ¶()¶Chấm dứt quá trình. Trên Unix, điều này được thực hiện bằng tín hiệu 68; Trên Windows 69 được sử dụng. Lưu ý rằng các trình xử lý thoát và cuối cùng là mệnh đề, v.v., sẽ không được thực thi.Lưu ý rằng các quá trình hậu duệ của quy trình sẽ không bị chấm dứt - chúng sẽ đơn giản trở nên mồ côi. Cảnh báo Nếu phương pháp này được sử dụng khi quá trình liên quan đang sử dụng đường ống hoặc hàng đợi thì đường ống hoặc hàng đợi có khả năng bị hỏng và có thể trở nên không thể sử dụng được bởi quy trình khác. Tương tự, nếu quá trình có được khóa hoặc semaphore, v.v. thì việc chấm dứt nó có thể khiến các quy trình khác bị bế tắc. giết chết()¶()¶Giống như 70 nhưng sử dụng tín hiệu 71 trên Unix.Mới trong phiên bản 3.7. gần()¶()¶Đóng đối tượng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9, phát hành tất cả các tài nguyên liên quan đến nó. 73 được nâng lên nếu quá trình cơ bản vẫn đang chạy. Khi 74 trả về thành công, hầu hết các phương thức và thuộc tính khác của đối tượng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 sẽ tăng 73.Mới trong phiên bản 3.7. gần()¶ Đóng đối tượng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9, phát hành tất cả các tài nguyên liên quan đến nó. 73 được nâng lên nếu quá trình cơ bản vẫn đang chạy. Khi 74 trả về thành công, hầu hết các phương thức và thuộc tính khác của đối tượng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 sẽ tăng 73. 7 Lưu ý rằng from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()2, 47, 79, 70 và 49 chỉ nên được gọi bởi quá trình tạo ra đối tượng quy trình.
multiprocessing.ProcessError¶Ví dụ sử dụng một số phương pháp của import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9: ngoại lệmultiprocessing.BufferTooShort¶ Ngoại lệ được nâng lên bởi 84 khi đối tượng bộ đệm được cung cấp quá nhỏ để đọc tin nhắn.Nếu 85 là một thể hiện của 86 thì 87 sẽ cung cấp thông báo dưới dạng chuỗi byte. Ngoại lệ.
multiprocessing.AuthenticationError¶Lớn lên khi có lỗi xác thực. Ngoại lệ.multiprocessing.TimeoutError¶Được nâng lên bởi các phương pháp với thời gian chờ khi hết thời gian chờ. Ống và hàng đợiKhi sử dụng nhiều quy trình, người ta thường sử dụng thông báo truyền cho giao tiếp giữa các quy trình và tránh phải sử dụng bất kỳ nguyên thủy đồng bộ hóa nào như khóa. Để truyền tin nhắn, người ta có thể sử dụng from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()2 (cho kết nối giữa hai quy trình) hoặc hàng đợi (cho phép nhiều nhà sản xuất và người tiêu dùng). Các loại from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0, 90 và 91 là các hàng đợi FIFO đa nhà sản xuất, đa người tiêu dùng được mô hình hóa trên lớp from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()1 trong thư viện tiêu chuẩn. Chúng khác nhau ở chỗ from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0 thiếu các phương pháp 94 và 47 được đưa vào lớp Python 2.5 tựa ____ ____91.Nếu bạn sử dụng 91 thì bạn phải gọi 98 cho mỗi nhiệm vụ bị xóa khỏi hàng đợi hoặc nếu không thì semaphore được sử dụng để đếm số lượng nhiệm vụ chưa hoàn thành cuối cùng có thể tràn ra, tăng một ngoại lệ.must call 98 for each task removed from the queue or else the semaphore used to count the number of
unfinished tasks may eventually overflow, raising an exception.Lưu ý rằng người ta cũng có thể tạo một hàng đợi được chia sẻ bằng cách sử dụng đối tượng Trình quản lý - xem Trình quản lý.Managers. Ghi chú Khi một đối tượng được đặt vào hàng đợi, đối tượng sẽ được ngâm và một luồng nền sau đó sẽ xả dữ liệu ngâm vào một đường ống bên dưới. Điều này có một số hậu quả hơi đáng ngạc nhiên, nhưng không nên gây ra bất kỳ khó khăn thực tế nào - nếu họ thực sự làm phiền bạn thì thay vào đó bạn có thể sử dụng hàng đợi được tạo với người quản lý.manager.
Cảnh báo Nếu một quá trình bị giết bằng cách sử dụng from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))03 hoặc from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))04 trong khi nó đang cố gắng sử dụng from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0, thì dữ liệu trong hàng đợi có khả năng bị hỏng. Điều này có thể gây ra bất kỳ quá trình nào khác để có một ngoại lệ khi nó cố gắng sử dụng hàng đợi sau này. Cảnh báo Nếu một quá trình bị giết bằng cách sử dụng from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))03 hoặc from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))04 trong khi nó đang cố gắng sử dụng from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0, thì dữ liệu trong hàng đợi có khả năng bị hỏng. Điều này có thể gây ra bất kỳ quá trình nào khác để có một ngoại lệ khi nó cố gắng sử dụng hàng đợi sau này. Như đã đề cập ở trên, nếu một quy trình trẻ em đã đặt các mục lên hàng đợi (và nó chưa sử dụng from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))06), thì quá trình đó sẽ không chấm dứt cho đến khi tất cả các vật phẩm được đệm đã được xả vào đường ống. Điều này có nghĩa là nếu bạn cố gắng tham gia vào quá trình đó, bạn có thể nhận được bế tắc trừ khi bạn chắc chắn rằng tất cả các mục đã được đặt vào hàng đợi đã được tiêu thụ. Tương tự, nếu quá trình con không phải là Daemonic thì quá trình cha mẹ có thể bị thoát ra khi họ cố gắng tham gia cùng tất cả những đứa trẻ không thuộc tính của nó.Programming guidelines. Lưu ý rằng một hàng đợi được tạo bằng cách sử dụng Trình quản lý không có vấn đề này. Xem Hướng dẫn lập trình.Examples. Để biết một ví dụ về việc sử dụng hàng đợi cho giao tiếp giữa các chuyên gia, hãy xem các ví dụ.Pipe([duplex])¶đa xử lý.pipe ([song công]) ¶ Trả về một cặp from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))07 của các đối tượng from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))08 đại diện cho các đầu của một đường ống. Nếu song công là 38 (mặc định) thì đường ống là hai chiều. Nếu song công là 39 thì đường ống là đơn hướng: from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))11 chỉ có thể được sử dụng để nhận tin nhắn và from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))12 chỉ có thể được sử dụng để gửi tin nhắn.multiprocessing.Queue([maxsize])¶ classMultipRocessing.queue ([MaxSize]) ¶ Trả về một hàng đợi được chia sẻ quy trình được triển khai bằng một đường ống và một vài khóa/semaphores. Khi một quá trình lần đầu tiên đặt một vật phẩm lên hàng đợi, một luồng bộ nạp được bắt đầu, chuyển các đối tượng từ bộ đệm vào đường ống. Các ngoại lệ from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))02 và from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))14 thông thường từ mô -đun thư viện tiêu chuẩn from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))15 được nâng lên để hết thời gian chờ tín hiệu. from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0 thực hiện tất cả các phương pháp của from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()1 ngoại trừ 94 và 47.()¶qsize () ¶ Trả lại kích thước gần đúng của hàng đợi. Do ngữ nghĩa đa luồng/đa xử lý, con số này không đáng tin cậy. Lưu ý rằng điều này có thể tăngfrom multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))20 trên các nền tảng UNIX như MacOS nơi from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))21 không được triển khai.()¶ trống rỗng()¶ Trả lại 38 Nếu hàng đợi trống, 39 khác. Do ngữ nghĩa đa luồng/đa xử lý, điều này không đáng tin cậy.()¶đầy()¶ Trả lại 38 Nếu hàng đợi đầy đủ, 39 khác. Do ngữ nghĩa đa luồng/đa xử lý, điều này không đáng tin cậy.(obj[, block[, timeout]])¶đặt (obj [, block [, thời gian chờ]]) ¶ put_nowait (obj) ¶(obj)¶Tương đương với from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))31. GET ([khối [, thời gian chờ]])([block[, timeout]])¶ Hủy bỏ và trả lại một mục từ hàng đợi. Nếu khối args tùy chọn là 38 (mặc định) và thời gian chờ là 32 (mặc định), khối nếu cần thiết cho đến khi có sẵn một mục. Nếu thời gian chờ là một số dương, nó sẽ chặn hầu hết các thời gian chờ giây và tăng ngoại lệ from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))02 nếu không có mục nào trong thời gian đó. Mặt khác (khối là 39), hãy trả lại một mục nếu có sẵn ngay lập tức, nếu không, hãy tăng ngoại lệ from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))02 (thời gian chờ bị bỏ qua trong trường hợp đó). Thay đổi trong phiên bản 3.8: Nếu hàng đợi được đóng, 73 is raised instead of from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))38. get_nowait ()()¶ Tương đương với from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))39. from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))40 có một vài phương pháp bổ sung không được tìm thấy trong from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()1. Các phương pháp này thường không cần thiết đối với hầu hết các mã: gần()¶()¶ Chỉ ra rằng sẽ không có thêm dữ liệu nào cho hàng đợi này theo quy trình hiện tại. Chủ đề nền sẽ thoát ra khi nó đã xóa tất cả dữ liệu được đệm vào đường ống. Điều này được gọi là tự động khi hàng đợi được thu thập rác. tham gia_thread () ¶()¶Tham gia chủ đề nền. Điều này chỉ có thể được sử dụng sau khi 74 đã được gọi. Nó chặn cho đến khi luồng nền thoát ra, đảm bảo rằng tất cả dữ liệu trong bộ đệm đã được xả vào đường ống.Theo mặc định nếu một quy trình không phải là người tạo hàng đợi thì khi thoát, nó sẽ cố gắng tham gia luồng nền hàng đợi. Quá trình này có thể gọi from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))43 để làm cho from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))44 không làm gì cả. Hủy_Join_Thread ()()¶ Ngăn chặn from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))44 chặn. Cụ thể, điều này ngăn chặn luồng nền được tham gia tự động khi quá trình thoát ra - xem from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))44. Một tên tốt hơn cho phương pháp này có thể là from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))47. Nó có khả năng khiến dữ liệu enqueued bị mất, và bạn gần như chắc chắn sẽ không cần phải sử dụng nó. Thực sự chỉ ở đó nếu bạn cần quy trình hiện tại để thoát ngay lập tức mà không chờ đợi để xóa dữ liệu vào đường ống bên dưới và bạn không quan tâm đến dữ liệu bị mất. Ghi chú Chức năng của lớp này yêu cầu triển khai semaphore được chia sẻ hoạt động trên hệ điều hành máy chủ. Nếu không có một, chức năng trong lớp này sẽ bị vô hiệu hóa và cố gắng khởi tạo from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0 sẽ dẫn đến from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))49. Xem BPO-3770 để biết thêm thông tin. Điều tương tự cũng đúng với bất kỳ loại hàng đợi chuyên dụng nào được liệt kê dưới đây. classmultiprocessing.simplequeue¶ multiprocessing.SimpleQueue¶ Nó là một loại from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0 đơn giản, rất gần với from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))51 bị khóa. gần()¶()¶ Chỉ ra rằng sẽ không có thêm dữ liệu nào cho hàng đợi này theo quy trình hiện tại. Chủ đề nền sẽ thoát ra khi nó đã xóa tất cả dữ liệu được đệm vào đường ống. Điều này được gọi là tự động khi hàng đợi được thu thập rác. tham gia_thread () ¶ Tham gia chủ đề nền. Điều này chỉ có thể được sử dụng sau khi from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))43 để làm cho from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))44 không làm gì cả.()¶ Hủy_Join_Thread () Ngăn chặnfrom multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))44 chặn. Cụ thể, điều này ngăn chặn luồng nền được tham gia tự động khi quá trình thoát ra - xem from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))44.()¶ Một tên tốt hơn cho phương pháp này có thể là from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))47. Nó có khả năng khiến dữ liệu enqueued bị mất, và bạn gần như chắc chắn sẽ không cần phải sử dụng nó. Thực sự chỉ ở đó nếu bạn cần quy trình hiện tại để thoát ngay lập tức mà không chờ đợi để xóa dữ liệu vào đường ống bên dưới và bạn không quan tâm đến dữ liệu bị mất. Ghi chú(item)¶ Chức năng của lớp này yêu cầu triển khai semaphore được chia sẻ hoạt động trên hệ điều hành máy chủ. Nếu không có một, chức năng trong lớp này sẽ bị vô hiệu hóa và cố gắng khởi tạo from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0 sẽ dẫn đến from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))49. Xem BPO-3770 để biết thêm thông tin. Điều tương tự cũng đúng với bất kỳ loại hàng đợi chuyên dụng nào được liệt kê dưới đây. classmultiprocessing.simplequeue¶ multiprocessing.JoinableQueue([maxsize])¶ Nó là một loại from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0 đơn giản, rất gần với from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))51 bị khóa. Đóng hàng đợi: Phát hành tài nguyên nội bộ.()¶ Một hàng đợi không được sử dụng nữa sau khi nó được đóng lại. Ví dụ, các phương thức from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))52, from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))53 và 99 không còn được gọi.Mới trong phiên bản 3.9. trống rỗng()¶ Trả lại 38 Nếu hàng đợi trống, 39 khác.()¶lấy()¶ Hủy bỏ và trả lại một mục từ hàng đợi. đặt (mục) ¶Đặt mục vào hàng đợi.active_children()¶classMultipRocessing.Joinablequeue ([MaxSize]) ¶ 91, một lớp con from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()0, là một hàng đợi mà còn có các phương thức 94 và 47.
Task_done ()cpu_count()¶Chỉ ra rằng một nhiệm vụ trước đây là hoàn thành. Được sử dụng bởi người tiêu dùng hàng đợi. Đối với mỗi from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))52 được sử dụng để tìm kiếm một nhiệm vụ, một cuộc gọi tiếp theo đến 94 cho thấy hàng đợi rằng việc xử lý trong nhiệm vụ đã hoàn tất.Nếu 47 hiện đang chặn, nó sẽ tiếp tục khi tất cả các mục đã được xử lý (có nghĩa là cuộc gọi 94 đã được nhận cho mọi mục đã được from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))53 vào hàng đợi). Tăng 73 nếu được gọi là nhiều lần hơn so với các mặt hàng được đặt trong hàng đợi. tham gia()¶current_process()¶Chặn cho đến khi tất cả các mục trong hàng đợi đã được xử lý và xử lý. Số lượng các nhiệm vụ chưa hoàn thành tăng lên bất cứ khi nào một mặt hàng được thêm vào hàng đợi. Số lượng đi xuống bất cứ khi nào người tiêu dùng gọi 94 để chỉ ra rằng mặt hàng đã được lấy và tất cả hoạt động trên đó hoàn tất. Khi số lượng các nhiệm vụ chưa hoàn thành giảm xuống 0, 47 không bị chặn.
Điều khoản khác¶parent_process()¶Đa xử lý.Active_Children () Mới trong phiên bản 3.8. đa xử lý.freeze_support () ¶freeze_support()¶Thêm hỗ trợ cho khi một chương trình sử dụng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 đã bị đóng băng để tạo ra một Windows có thể thực thi. (Đã được thử nghiệm với PY2EXE, Pyinstaller và CX_Freeze.)py2exe, PyInstaller and cx_Freeze.) Người ta cần gọi chức năng này ngay sau dòng from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))78 của mô -đun chính. Ví dụ: 8Nếu dòng from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))79 bị bỏ qua thì cố gắng chạy thực thi đóng băng sẽ tăng from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))80. Gọi from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))79 không có hiệu lực khi được gọi trên bất kỳ hệ điều hành nào khác ngoài Windows. Ngoài ra, nếu mô -đun được chạy bình thường bởi trình thông dịch Python trên Windows (chương trình chưa bị đóng băng), thì from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))79 không có hiệu lực. Đa xử lý.get_all_start_methods () ¶get_all_start_methods()¶ Trả về một danh sách các phương thức bắt đầu được hỗ trợ, trong số đó là mặc định. Các phương pháp bắt đầu có thể là from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6 và from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7. Trên Windows chỉ có sẵn from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6. Trên Unix from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8 và from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6 luôn được hỗ trợ, với from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8 là mặc định. Mới trong phiên bản 3.4. MultipRcessing.Get_Context (Phương thức = Không) ¶get_context(method=None)¶Trả về một đối tượng ngữ cảnh có cùng thuộc tính với mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8. Nếu phương thức là 32 thì bối cảnh mặc định được trả về. Mặt khác, phương pháp phải là from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7. 73 được nâng lên nếu phương thức bắt đầu được chỉ định không có sẵn.
Mới trong phiên bản 3.4. MultipRcessing.Get_Context (Phương thức = Không) ¶get_start_method(allow_none=False)¶Trả về một đối tượng ngữ cảnh có cùng thuộc tính với mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8. Nếu phương thức là 32 thì bối cảnh mặc định được trả về. Mặt khác, phương pháp phải là from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7. 73 được nâng lên nếu phương thức bắt đầu được chỉ định không có sẵn.Đa xử lý.Get_Start_Method (allow_none = false) ¶ Trả về tên của phương thức bắt đầu được sử dụng cho các quá trình bắt đầu.On macOS, the spawn start method is now the default. The fork start method should be considered unsafe as it can lead to crashes of the subprocess. See bpo-33725. Mới trong phiên bản 3.4. MultipRcessing.Get_Context (Phương thức = Không) ¶set_executable(executable)¶Trả về một đối tượng ngữ cảnh có cùng thuộc tính với mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8. 9Nếu phương thức là 32 thì bối cảnh mặc định được trả về. Mặt khác, phương pháp phải là from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7. 73 được nâng lên nếu phương thức bắt đầu được chỉ định không có sẵn.Đa xử lý.Get_Start_Method (allow_none = false) ¶Now supported on Unix when the from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6 start method is used. Trả về tên của phương thức bắt đầu được sử dụng cho các quá trình bắt đầu.set_start_method(method)¶ Nếu phương thức bắt đầu chưa được sửa và cho phép_none là sai, thì phương thức bắt đầu được cố định vào mặc định và tên được trả về. Nếu phương thức bắt đầu chưa được sửa và allow_none là đúng thì 32 sẽ được trả về.Giá trị trả về có thể là from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7 hoặc 32. from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8 là mặc định trên UNIX, trong khi from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6 là mặc định trên Windows và MacOS. Mới trong phiên bản 3.4. MultipRcessing.Get_Context (Phương thức = Không) ¶Trả về một đối tượng ngữ cảnh có cùng thuộc tính với mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8. Nếu phương thức là 32 thì bối cảnh mặc định được trả về. Mặt khác, phương pháp phải là from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7. 73 được nâng lên nếu phương thức bắt đầu được chỉ định không có sẵn.Listeners and Clients. Đa xử lý.Get_Start_Method (allow_none = false) ¶
multiprocessing.connection.Connection¶
send(obj)¶Trả về tên của phương thức bắt đầu được sử dụng cho các quá trình bắt đầu. Nếu phương thức bắt đầu chưa được sửa và cho phép_none là sai, thì phương thức bắt đầu được cố định vào mặc định và tên được trả về. Nếu phương thức bắt đầu chưa được sửa và allow_none là đúng thì 32 sẽ được trả về. Giá trị trả về có thể là from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7 hoặc 32. from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8 là mặc định trên UNIX, trong khi from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6 là mặc định trên Windows và MacOS.()¶ Đã thay đổi trong phiên bản 3.8: Trên macOS, phương thức bắt đầu sinh sản hiện là mặc định. Phương pháp bắt đầu ngã ba nên được coi là không an toàn vì nó có thể dẫn đến các sự cố của quá trình phụ. Xem BPO-33725. Đa xử lý.set_executable (thực thi) ¶()¶Đặt đường dẫn của trình thông dịch Python để sử dụng khi bắt đầu quy trình con. (Theo mặc định from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()03 được sử dụng). Người nhúng có thể sẽ cần phải làm một số việc như trước khi họ có thể tạo ra các quá trình trẻ em.()¶ Đã thay đổi trong phiên bản 3.4: hiện được hỗ trợ trên UNIX khi phương thức bắt đầu from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6 được sử dụng. Đa xử lý.set_start_method (Phương pháp) ¶ Đặt phương pháp nên được sử dụng để bắt đầu các quá trình con. Phương pháp có thể làfrom multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()8, from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()6 hoặc from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()7.([timeout])¶ Lưu ý rằng điều này nên được gọi nhiều nhất một lần và nó nên được bảo vệ bên trong mệnh đề from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()5 của mô -đun chính. Đối tượng kết nối Các đối tượng kết nối cho phép gửi và nhận các đối tượng hoặc chuỗi có thể chọn được. Chúng có thể được coi là ổ cắm được kết nối theo định hướng tin nhắn. Các đối tượng kết nối thường được tạo bằng cách sử dụngfrom multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))51 - xem thêm người nghe và máy khách.(buffer[, offset[, size]])¶ ClassMultIpRocessing.Connection.Connection¶ gửi (OBJ) ¶bytes-like object as a complete message. Gửi một đối tượng đến đầu kia của kết nối cần đọc bằng from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()5. Đối tượng phải được chọn. Pickles rất lớn (khoảng 32 mib+, mặc dù nó phụ thuộc vào HĐH) có thể tăng ngoại lệ 73.([maxlength])¶recv () Nếu MAXLEPT được chỉ định và thông báo dài hơn Maxlength thì from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))38 được tăng lên và kết nối sẽ không còn có thể đọc được. Đã thay đổi trong phiên bản 3.3: Hàm này được sử dụng để tăng from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()19, which is now an alias of from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))38. recv_bytes_into (bộ đệm [, offset]) ¶(buffer[, offset])¶ Đọc vào bộ đệm Một thông báo đầy đủ về dữ liệu byte được gửi từ đầu kia của kết nối và trả về số byte trong tin nhắn. Khối cho đến khi có một cái gì đó để nhận. Tăng from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()13 nếu không còn gì để nhận và đầu kia đã bị đóng lại. Bộ đệm phải là một đối tượng giống như byte có thể ghi. Nếu bù được đưa ra thì thông báo sẽ được ghi vào bộ đệm từ vị trí đó. Offset phải là một số nguyên không âm nhỏ hơn chiều dài của bộ đệm (tính bằng byte).bytes-like object. If offset is given then the message will be written into the buffer from that position. Offset must be a non-negative integer less than the length of buffer (in bytes). Nếu bộ đệm quá ngắn thì ngoại lệ 86 được nêu ra và thông báo hoàn chỉnh có sẵn dưới dạng 87 trong đó 85 là thể hiện ngoại lệ.Đã thay đổi trong phiên bản 3.3: Bản thân các đối tượng kết nối hiện có thể được chuyển giữa các quy trình bằng cách sử dụng from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()25 and from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()26. Ví dụ: from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))0 Cảnh báo Phương thức from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()26 tự động giải nén dữ liệu mà nó nhận được, có thể là rủi ro bảo mật trừ khi bạn có thể tin tưởng vào quá trình đã gửi tin nhắn. Do đó, trừ khi đối tượng kết nối được tạo bằng from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()2, bạn chỉ nên sử dụng các phương thức from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()5 và from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()4 sau khi thực hiện một số loại xác thực. Xem các khóa xác thực.Authentication keys. Cảnh báo Phương thức from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()26 tự động giải nén dữ liệu mà nó nhận được, có thể là rủi ro bảo mật trừ khi bạn có thể tin tưởng vào quá trình đã gửi tin nhắn. Do đó, trừ khi đối tượng kết nối được tạo bằng from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start() 2, bạn chỉ nên sử dụng các phương thức from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start() 5 và from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start() 4 sau khi thực hiện một số loại xác thực. Xem các khóa xác thực.Nếu một quá trình bị giết trong khi nó đang cố đọc hoặc ghi vào một đường ống thì dữ liệu trong đường ống có khả năng bị hỏng, bởi vì nó có thể trở nên không thể chắc chắn rằng ranh giới thông điệp nằm ở đâu. Đồng bộ hóa nguyên thủyManagers. Nói chung, các nguyên thủy đồng bộ hóa không cần thiết trong một chương trình đa xử lý như trong một chương trình đa luồng. Xem tài liệu cho mô -đunimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9.multiprocessing.Barrier(parties[, action[, timeout]])¶ Lưu ý rằng người ta cũng có thể tạo các nguyên thủy đồng bộ hóa bằng cách sử dụng đối tượng Trình quản lý - xem Trình quản lý. classMultipRocessing.Barrier (các bên [, hành động [, thời gian chờ]]) ¶ Một đối tượng rào cản: Một bản sao củafrom multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()32.multiprocessing.BoundedSemaphore([value])¶ Mới trong phiên bản 3.3. classMultipRocessing.boundedSemaphore ([giá trị]) ¶ Một đối tượng semaphore giới hạn: Một chất tương tự gần của from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()33. Một sự khác biệt đơn độc so với các chất tương tự gần của nó tồn tại: đối số đầu tiên của phương thức ____334 của nó có tên là khối, phù hợp với from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()35. Ghi chú multiprocessing.Condition([lock])¶ Trên các macOS, điều này không thể phân biệt được từ 16 vì from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))21 không được triển khai trên nền tảng đó. classMultipRocessing.Condition ([khóa]) ¶ Một biến điều kiện: Một bí danh cho from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()42 method was added. Nếu khóa được chỉ định thì nó phải là đối tượng 14 hoặc 15 từ import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8. multiprocessing.Event¶ Thay đổi trong phiên bản 3.3: Phương pháp from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()42 đã được thêm vào. ClassMultIprocessing.Event¶ multiprocessing.Lock¶ Một bản sao của from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()43. ClassMultIprocessing.Lock¶ Một đối tượng khóa không nhận được: một chất tương tự gần from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()44. Khi một quy trình hoặc luồng đã có được một khóa, các nỗ lực tiếp theo để có được nó từ bất kỳ quy trình hoặc luồng nào sẽ chặn cho đến khi nó được phát hành; Bất kỳ quá trình hoặc chủ đề có thể phát hành nó. Các khái niệm và hành vi của from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()44 vì nó áp dụng cho các luồng được nhân rộng ở đây trong from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()46 vì nó áp dụng cho một trong hai quy trình hoặc luồng, trừ khi được ghi chú.context manager protocol and thus may be used in from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()50 statements. Lưu ý rằng 14 thực sự là một chức năng nhà máy trả về một thể hiện from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()48 được khởi tạo với bối cảnh mặc định.(block=True, timeout=None)¶ 14 hỗ trợ giao thức Trình quản lý bối cảnh và do đó có thể được sử dụng trong các câu lệnh from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()50. Mua lại (block = true, thời gian chờ = none) ¶ Có được một khóa, chặn hoặc không chặn. Với đối số khối được đặt thành 38 (mặc định), cuộc gọi phương thức sẽ chặn cho đến khi khóa ở trạng thái không khóa, sau đó đặt nó thành khóa và trả lại 38. Lưu ý rằng tên của đối số đầu tiên này khác với tên trong from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()53. phóng thích()¶()¶ Phát hành khóa. Điều này có thể được gọi từ bất kỳ quy trình hoặc luồng, không chỉ quy trình hoặc luồng ban đầu có được khóa. Hành vi giống như trong from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()63 ngoại trừ khi được gọi trên khóa đã mở khóa, 73 được nâng lên. ClassMultIprocessing.Rlock¶
multiprocessing.RLock¶Một đối tượng khóa đệ quy: Một chất tương tự gần from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()65. Một khóa đệ quy phải được phát hành bởi quy trình hoặc luồng có được nó. Khi một quá trình hoặc luồng đã có được một khóa đệ quy, cùng một quy trình hoặc luồng có thể có được nó một lần nữa mà không chặn; Quá trình hoặc chủ đề đó phải phát hành nó một lần cho mỗi lần nó được mua lại. Lưu ý rằng 15 thực sự là một chức năng nhà máy trả về một thể hiện from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()67 được khởi tạo với bối cảnh mặc định. 15 hỗ trợ giao thức Trình quản lý bối cảnh và do đó có thể được sử dụng trong các câu lệnh from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()50.context manager protocol and thus may be used in from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()50 statements. Mua lại (block = true, thời gian chờ = none) ¶(block=True, timeout=None)¶ Có được một khóa, chặn hoặc không chặn. Khi được gọi với đối số khối được đặt thành 38, chặn cho đến khi khóa ở trạng thái mở khóa (không thuộc sở hữu của bất kỳ quy trình hoặc luồng nào) trừ khi khóa đã thuộc sở hữu của quy trình hoặc luồng hiện tại. Quy trình hoặc luồng hiện tại sau đó có quyền sở hữu khóa (nếu nó chưa có quyền sở hữu) và mức đệ quy bên trong mức tăng của khóa, dẫn đến giá trị trả lại là 38. Lưu ý rằng có một số khác biệt trong hành vi đối số đầu tiên này so với việc thực hiện from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()72, bắt đầu với tên của chính đối số. Khi được gọi với đối số khối được đặt thành 39, không chặn. Nếu khóa đã được mua (và do đó được sở hữu) bởi một quy trình hoặc luồng khác, quy trình hoặc luồng hiện tại không có quyền sở hữu và mức đệ quy trong khóa không thay đổi, dẫn đến giá trị trả lại là 39. Nếu khóa ở trạng thái không khóa, quy trình hoặc luồng hiện tại sẽ sở hữu và mức đệ quy được tăng lên, dẫn đến giá trị trả lại là 38.Sử dụng và hành vi của đối số thời gian chờ giống như trong from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()35. Lưu ý rằng một số hành vi thời gian chờ này khác với các hành vi được thực hiện trong from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()72. phóng thích()¶()¶ Phát hành khóa, giảm mức đệ quy. Nếu sau khi mức độ đệ quy bằng 0, hãy đặt lại khóa để mở khóa (không thuộc sở hữu của bất kỳ quy trình hoặc luồng nào) và nếu bất kỳ quy trình hoặc luồng nào khác bị chặn chờ khóa được mở khóa, hãy cho phép chính xác một trong số chúng tiến hành. Nếu sau khi giảm mức đệ quy vẫn còn khác, thì khóa vẫn bị khóa và sở hữu bởi quá trình gọi hoặc luồng. Chỉ gọi phương thức này khi quá trình gọi hoặc luồng sở hữu khóa. Một from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()78 được nâng lên nếu phương thức này được gọi bởi một quy trình hoặc luồng khác ngoài chủ sở hữu hoặc nếu khóa ở trạng thái không khóa (chưa được mở). Lưu ý rằng loại ngoại lệ được nêu trong tình huống này khác với hành vi được thực hiện trong from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()79. classMultipRocessing.Semaphore ([giá trị]) ¶multiprocessing.Semaphore([value])¶ Một đối tượng semaphore: Một chất tương tự gần của from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()80. Một sự khác biệt đơn độc so với các chất tương tự gần của nó tồn tại: đối số đầu tiên của phương thức ____334 của nó có tên là khối, phù hợp với from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()35. Ghi chú Trên các macOS, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()83 không được hỗ trợ, vì vậy gọi from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()84 với thời gian chờ sẽ mô phỏng hành vi chức năng đó bằng cách sử dụng vòng ngủ. Ghi chú Trên các macOS, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()83 không được hỗ trợ, vì vậy gọi from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()84 với thời gian chờ sẽ mô phỏng hành vi chức năng đó bằng cách sử dụng vòng ngủ. Nếu tín hiệu SIGINT được tạo bởi CTRL-C đến trong khi luồng chính bị chặn bởi một cuộc gọi đến from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()85, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()35, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()87, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()88, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()89 hoặc from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()90 thì cuộc gọi sẽ bị gián đoạn ngay lập tức và from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()91 sẽ được tăng lên. Ghi chú Trên các macOS, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()83 không được hỗ trợ, vì vậy gọi from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()84 với thời gian chờ sẽ mô phỏng hành vi chức năng đó bằng cách sử dụng vòng ngủ. Nếu tín hiệu SIGINT được tạo bởi CTRL-C đến trong khi luồng chính bị chặn bởi một cuộc gọi đến from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() 85, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() 35, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() 87, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() 88, from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() 89 hoặc from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() 90 thì cuộc gọi sẽ bị gián đoạn ngay lập tức và from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() 91 sẽ được tăng lên.Điều này khác với hành vi của import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 nơi Sigint sẽ bị bỏ qua trong khi các cuộc gọi chặn tương đương đang được tiến hành. Một số chức năng của gói này yêu cầu triển khai semaphore được chia sẻ hoạt động trên hệ điều hành máy chủ. Không có một, mô -đun from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()93 sẽ bị vô hiệu hóa và cố gắng nhập nó sẽ dẫn đến from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))49. Xem BPO-3770 để biết thêm thông tin.Value(typecode_or_type, *args, lock=True)¶ Chia sẻ from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()95 Đối tượng Có thể tạo các đối tượng được chia sẻ bằng bộ nhớ chia sẻ có thể được kế thừa bởi các quá trình con. Nếu khóa là 38 (mặc định) thì một đối tượng khóa đệ quy mới được tạo để đồng bộ hóa quyền truy cập vào giá trị. Nếu khóa là đối tượng 14 hoặc 15 thì sẽ được sử dụng để đồng bộ hóa quyền truy cập vào giá trị. Nếu khóa là 39 thì quyền truy cập vào đối tượng được trả về sẽ không được khóa tự động được bảo vệ, do đó, nó sẽ không nhất thiết phải là xử lý an toàn.Các hoạt động như from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()03 liên quan đến việc đọc và viết không phải là nguyên tử. Vì vậy, nếu, ví dụ, bạn muốn tăng về mặt nguyên tử một giá trị chia sẻ thì nó không đủ Giả sử khóa được liên kết là đệ quy (theo mặc định) thay vào đó bạn có thể làm from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))1 Lưu ý rằng khóa là một đối số chỉ từ khóa. Multiprocessing.Array (typecode_or_type, size_or_initializer, *, lock = true) ¶Array(typecode_or_type, size_or_initializer, *, lock=True)¶Trả về một mảng CTYPE được phân bổ từ bộ nhớ chia sẻ. Theo mặc định, giá trị trả về thực sự là một trình bao bọc được đồng bộ hóa cho mảng. Typecode_or_type xác định loại phần tử của mảng được trả về: đó là loại CTYPES hoặc một kiểu chữ một ký tự của loại được sử dụng bởi mô -đun 05. Nếu size_or_initializer là một số nguyên, thì nó xác định độ dài của mảng và mảng sẽ ban đầu được xác định. Mặt khác, size_or_initializer là một chuỗi được sử dụng để khởi tạo mảng và độ dài xác định độ dài của mảng.Nếu khóa là 38 (mặc định) thì một đối tượng khóa mới được tạo để đồng bộ hóa quyền truy cập vào giá trị. Nếu khóa là đối tượng 14 hoặc 15 thì sẽ được sử dụng để đồng bộ hóa quyền truy cập vào giá trị. Nếu khóa là 39 thì quyền truy cập vào đối tượng được trả về sẽ không được khóa tự động được bảo vệ, do đó, nó sẽ không nhất thiết phải là xử lý an toàn.Lưu ý rằng khóa là một đối số chỉ từ khóa. Lưu ý rằng một mảng from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()09 có giá trị và các thuộc tính thô cho phép người ta sử dụng nó để lưu trữ và truy xuất các chuỗi. Mô -đun from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
|
ctypes | SharedCtypes sử dụng loại | SharedCtypes bằng cách sử dụng typecode |
---|---|---|
c_double(2.4) | RawValue (C_Double, 2.4) | RawValue (‘D, 2.4) |
MyStruct (4, 6) | RawValue (MyStruct, 4, 6) | |
(c_short * 7) () | RawArray (C_Short, 7) | RawArray (‘H, 7) |
(C_int * 3) (9, 2, 8) | RawArray (C_int, (9, 2, 8)) | RawArray (‘I, (9, 2, 8)) |
Dưới đây là một ví dụ trong đó một số đối tượng CTYPES được sửa đổi bởi một quy trình con:
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))2
Kết quả được in là
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))3
Người quản lý và
Các nhà quản lý cung cấp một cách để tạo dữ liệu có thể được chia sẻ giữa các quy trình khác nhau, bao gồm chia sẻ qua mạng giữa các quy trình chạy trên các máy khác nhau. Đối tượng Trình quản lý kiểm soát một quy trình máy chủ quản lý các đối tượng được chia sẻ. Các quy trình khác có thể truy cập các đối tượng được chia sẻ bằng cách sử dụng proxy.
đa xử lý.Manager ()Manager()¶Trả về đối tượng
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()37 bắt đầu có thể được sử dụng để chia sẻ các đối tượng giữa các quy trình. Đối tượng Trình quản lý được trả về tương ứng với quy trình con được sinh ra và có các phương thức sẽ tạo các đối tượng được chia sẻ và trả về các proxy tương ứng.
Các quy trình của người quản lý sẽ được tắt ngay khi chúng được thu thập rác hoặc quy trình cha mẹ của họ thoát ra. Các lớp Trình quản lý được xác định trong mô -đun
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()38: ClassMultipRocessing.Managers.Basemanager (address = none, authkey = none, serializer = 'pickle', ctx = none, *, shutdown_timeout = 1.0) ¶ multiprocessing.managers.BaseManager(address=None, authkey=None, serializer='pickle', ctx=None, *, shutdown_timeout=1.0)¶
Tạo một đối tượng Basemanager.
Sau khi được tạo, người ta nên gọi
from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()2 hoặc
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()40 để đảm bảo rằng đối tượng Trình quản lý đề cập đến quy trình quản lý đã bắt đầu.
Địa chỉ là địa chỉ mà quá trình trình quản lý lắng nghe các kết nối mới. Nếu địa chỉ là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì một địa chỉ tùy ý được chọn.AuthKey là khóa xác thực sẽ được sử dụng để kiểm tra tính hợp lệ của các kết nối đến với quy trình máy chủ. Nếu authkey là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()43 được sử dụng. Nếu không, AuthKey được sử dụng và nó phải là một chuỗi byte.
Bộ tuần tự phải là
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()44 (sử dụng
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()45 tuần tự hóa) hoặc
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()46 (sử dụng
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()47 tuần tự hóa).
CTX là một đối tượng bối cảnh hoặc
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 (sử dụng bối cảnh hiện tại). Xem hàm from multiprocessing import Process, Pipe def f(conn): conn.send([42, None, 'hello']) conn.close() if __name__ == '__main__': parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() print(parent_conn.recv()) # prints "[42, None, 'hello']" p.join()4.
Shutdown_Timeout là thời gian chờ tính bằng giây được sử dụng để đợi cho đến khi quá trình được người quản lý sử dụng hoàn thành trong phương thức
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()50. Nếu thời gian tắt máy, quá trình bị chấm dứt. Nếu chấm dứt quá trình cũng hết lần, quá trình bị giết.
Đã thay đổi trong phiên bản 3.11: Đã thêm tham số Shutdown_Timeout.Added the shutdown_timeout parameter.
Bắt đầu ([Khởi tạo [, initargs]]) ¶([initializer[, initargs]])¶Bắt đầu một quy trình con để bắt đầu người quản lý. Nếu bộ khởi tạo không phải là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì quá trình phụ sẽ gọi from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()52 khi nó bắt đầu. get_server () ¶()¶
Trả về một đối tượng
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()53 đại diện cho máy chủ thực tế dưới sự kiểm soát của người quản lý. Đối tượng
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()53 hỗ trợ phương thức
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()55:
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))4
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()53 Ngoài ra còn có thuộc tính
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()57. liên kết()¶()¶
Kết nối đối tượng Trình quản lý cục bộ với quy trình Trình quản lý từ xa:
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))5 tắt()¶()¶
Dừng quá trình được sử dụng bởi người quản lý. Điều này chỉ có sẵn nếu
from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start() print(q.get()) # prints "[42, None, 'hello']" p.join()2 đã được sử dụng để bắt đầu quá trình máy chủ.
Điều này có thể được gọi là nhiều lần.
Đăng ký (typeid [, có thể gọi được [, proxyType [, lộ [, meather_to_typeid [, created_method]]]]]])(typeid[, callable[, proxytype[, exposed[, method_to_typeid[, create_method]]]]])¶Một lớp học có thể được sử dụng để đăng ký một loại hoặc có thể gọi với lớp Trình quản lý.
Kiểu mẫu là một định danh loại hình thành, được sử dụng để xác định một loại đối tượng được chia sẻ cụ thể. Đây phải là một chuỗi.
Callable là một cuộc gọi được sử dụng để tạo các đối tượng cho định danh loại này. Nếu một phiên bản trình quản lý sẽ được kết nối với máy chủ bằng phương thức
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()59 hoặc nếu đối số created_method là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
39 thì điều này có thể được để lại là from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32.ProxyType là một lớp con của
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()62 được sử dụng để tạo proxy cho các đối tượng được chia sẻ với kiểu chữ này. Nếu
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì một lớp proxy được tạo tự động.được phơi bày được sử dụng để chỉ định một chuỗi các tên phương thức mà proxy cho loại hình này nên được phép truy cập bằng cách sử dụng
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()64. . .
Phương thức_TO_TYPEID là một ánh xạ được sử dụng để chỉ định loại trả về của các phương thức tiếp xúc đó sẽ trả về proxy. Nó ánh xạ tên phương thức thành các chuỗi kiểu chữ. .
created_method xác định xem một phương thức có nên được tạo bằng tên typeid có thể được sử dụng để nói với quy trình máy chủ để tạo một đối tượng được chia sẻ mới và trả về proxy cho nó. Theo mặc định, đó là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
38.from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()73 Các trường hợp cũng có một thuộc tính chỉ đọc: địa chỉ¶¶
Địa chỉ được sử dụng bởi người quản lý.
Đã thay đổi trong phiên bản 3.3: Đối tượng Trình quản lý hỗ trợ Giao thức quản lý bối cảnh - Xem các loại Trình quản lý ngữ cảnh. from multiprocessing import Process
import os
def info(title):
print(title)
print('module name:', __name__)
print('parent process:', os.getppid())
print('process id:', os.getpid())
def f(name):
info('function f')
print('hello', name)
if __name__ == '__main__':
info('main line')
p = Process(target=f, args=('bob',))
p.start()
p.join()
74 bắt đầu quá trình máy chủ (nếu nó chưa bắt đầu) và sau đó trả về đối tượng Trình quản lý. from multiprocessing import Process
import os
def info(title):
print(title)
print('module name:', __name__)
print('parent process:', os.getppid())
print('process id:', os.getpid())
def f(name):
info('function f')
print('hello', name)
if __name__ == '__main__':
info('main line')
p = Process(target=f, args=('bob',))
p.start()
p.join()
75 gọi from multiprocessing import Process
import os
def info(title):
print(title)
print('module name:', __name__)
print('parent process:', os.getppid())
print('process id:', os.getpid())
def f(name):
info('function f')
print('hello', name)
if __name__ == '__main__':
info('main line')
p = Process(target=f, args=('bob',))
p.start()
p.join()
50.Manager objects support the context management protocol – see Context Manager Types.
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()74 starts the server process (if it has not already started) and then returns the manager object.
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()75 calls
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()50.
Trong các phiên bản trước
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()74 đã không bắt đầu quy trình máy chủ của người quản lý nếu nó chưa bắt đầu. ClassMultIprocessing.Managers.syncManager¶multiprocessing.managers.SyncManager¶
Một lớp con của
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()73 có thể được sử dụng để đồng bộ hóa các quá trình. Các đối tượng thuộc loại này được trả về bởi
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()79.
Các phương thức của nó tạo và trả về các đối tượng proxy cho một số loại dữ liệu thường được sử dụng để được đồng bộ hóa trong các quy trình. Điều này đáng chú ý bao gồm danh sách và từ điển được chia sẻ.Proxy Objects for a number of commonly used data types to be synchronized across processes. This notably includes shared lists and dictionaries.
Rào cản (các bên [, hành động [, thời gian chờ]])(parties[, action[, timeout]])¶Tạo một đối tượng
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()32 được chia sẻ và trả về một proxy cho nó.
Mới trong phiên bản 3.3.
Bị ràng buộc([value])¶Tạo một đối tượng
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()33 được chia sẻ và trả về một proxy cho nó. Điều kiện ([khóa]) ¶([lock])¶
Tạo một đối tượng
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()38 được chia sẻ và trả về một proxy cho nó.
Nếu khóa được cung cấp thì nó phải là một proxy cho đối tượng
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()44 hoặc
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()65.
Thay đổi trong phiên bản 3.3: Phương pháp from multiprocessing import Process
def f(name):
print('hello', name)
if __name__ == '__main__':
p = Process(target=f, args=('bob',))
p.start()
p.join()
42 đã được thêm vào.The
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()42 method was added. Biến cố()¶()¶
Tạo một đối tượng
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()43 được chia sẻ và trả về một proxy cho nó. Khóa()¶()¶
Tạo một đối tượng
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()44 được chia sẻ và trả về một proxy cho nó. Không gian tên ()()¶
Tạo một đối tượng
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
13 được chia sẻ và trả về một proxy cho nó.
Hàng đợi ([Maxsize])([maxsize])¶Tạo một đối tượng
from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()1 được chia sẻ và trả về một proxy cho nó. Rlock () ¶()¶
Tạo một đối tượng
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()65 được chia sẻ và trả về một proxy cho nó. Semaphore ([giá trị]) ¶([value])¶
Tạo một đối tượng
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()80 được chia sẻ và trả về một proxy cho nó. Mảng (Typecode, trình tự) ¶(typecode, sequence)¶
Tạo một mảng và trả về một proxy cho nó.
Giá trị (kiểu chữ, giá trị) ¶(typecode, value)¶Tạo một đối tượng với thuộc tính
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()18 có thể ghi và trả về một proxy cho nó. Dict () Dict (Bản đồ) Dict (trình tự)()¶ dict(mapping) dict(sequence)
Tạo một đối tượng
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
12 được chia sẻ và trả về một proxy cho nó. Danh sách () Danh sách (trình tự)()¶
list(sequence)Tạo một đối tượng
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
11 được chia sẻ và trả về một proxy cho nó.Thay đổi trong phiên bản 3.6: Các đối tượng được chia sẻ có khả năng được lồng. Ví dụ: một đối tượng container được chia sẻ như danh sách chia sẻ có thể chứa các đối tượng được chia sẻ khác, tất cả sẽ được quản lý và đồng bộ hóa bởi from multiprocessing import Process
import os
def info(title):
print(title)
print('module name:', __name__)
print('parent process:', os.getppid())
print('process id:', os.getpid())
def f(name):
info('function f')
print('hello', name)
if __name__ == '__main__':
info('main line')
p = Process(target=f, args=('bob',))
p.start()
p.join()
37.Shared objects are capable of being nested. For example, a shared container object such as a shared list can contain other shared objects which will all be managed and
synchronized by the
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()37. classMultiprocessing.Managers.namespace¶ multiprocessing.managers.Namespace¶
Một loại có thể đăng ký với
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()37.
Một đối tượng không gian tên không có phương thức công khai, nhưng có các thuộc tính có thể ghi. Đại diện của nó cho thấy các giá trị của các thuộc tính của nó.
Tuy nhiên, khi sử dụng proxy cho đối tượng không gian tên, một thuộc tính bắt đầu bằng
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()68 sẽ là một thuộc tính của proxy và không phải là thuộc tính của người giới thiệu:
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))6
Người quản lý tùy chỉnh
Để tạo một người quản lý riêng, một người tạo một lớp con là
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()73 và sử dụng lớp
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()99 để đăng ký các loại hoặc thiết bị gọi mới với lớp Trình quản lý. Ví dụ:
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))7
Sử dụng Trình quản lý từ xa
Có thể chạy máy chủ Trình quản lý trên một máy và yêu cầu khách hàng sử dụng nó từ các máy khác (giả sử rằng tường lửa liên quan cho phép nó).
Chạy các lệnh sau tạo một máy chủ cho một hàng đợi được chia sẻ duy nhất mà máy khách từ xa có thể truy cập:
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))8
Một ứng dụng khách có thể truy cập máy chủ như sau:
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))9
Một khách hàng khác cũng có thể sử dụng nó:
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()0
Các quy trình cục bộ cũng có thể truy cập hàng đợi đó, sử dụng mã từ phía trên trên máy khách để truy cập nó từ xa:
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()1
Đối tượng proxy công
Proxy là một đối tượng đề cập đến một đối tượng được chia sẻ sống (có lẽ) trong một quy trình khác. Đối tượng được chia sẻ được cho là người giới thiệu của proxy. Nhiều đối tượng proxy có thể có cùng người giới thiệu.
Một đối tượng proxy có các phương thức gọi các phương thức tương ứng của người giới thiệu của nó (mặc dù không phải mọi phương thức của người giới thiệu sẽ nhất thiết có sẵn thông qua proxy). Theo cách này, một proxy có thể được sử dụng giống như người giới thiệu của nó có thể:
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()2
Lưu ý rằng việc áp dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()00 cho proxy sẽ trả về biểu diễn của người giới thiệu, trong khi việc áp dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()01 sẽ trả về đại diện của proxy.
Một tính năng quan trọng của các đối tượng proxy là chúng có thể chọn được để chúng có thể được thông qua giữa các quy trình. Như vậy, một người giới thiệu có thể chứa các đối tượng proxy. Điều này cho phép làm tổ của các danh sách được quản lý, dicts và các đối tượng proxy khác:Proxy Objects. This permits nesting of these managed lists, dicts, and other Proxy Objects:
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()3
Tương tự, các proxy Dict và List có thể được lồng vào nhau:
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()4
Nếu các đối tượng tiêu chuẩn (không proxy)
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
11 hoặc from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
12 được chứa trong một người giới thiệu, việc sửa đổi các giá trị có thể thay đổi đó sẽ không được truyền qua người quản lý vì proxy không có cách nào để biết khi nào các giá trị có trong đó được sửa đổi. Tuy nhiên, việc lưu trữ giá trị trong proxy container (kích hoạt import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()04 trên đối tượng proxy) tuyên truyền thông qua người quản lý và do đó để sửa đổi hiệu quả một mục đó, người ta có thể gán lại giá trị đã sửa đổi cho proxy container:
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()5
Cách tiếp cận này có lẽ ít thuận tiện hơn so với việc sử dụng các đối tượng proxy lồng nhau cho hầu hết các trường hợp sử dụng nhưng cũng cho thấy mức độ kiểm soát đối với việc đồng bộ hóa.Proxy Objects for most use cases but also demonstrates a level of control over the synchronization.
Ghi chú
Các loại proxy trong
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 không làm gì để hỗ trợ so sánh theo giá trị. Vì vậy, ví dụ, chúng tôi có:
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()6
Người ta chỉ nên sử dụng một bản sao của người giới thiệu thay vì so sánh.
ClassMultIprocessing.Managers.Baseproxy¶ multiprocessing.managers.BaseProxy¶Các đối tượng proxy là các trường hợp của các lớp con của
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()62. _CallMethod (Phương thức [, args [, kwds]]) ¶(methodname[, args[, kwds]])¶
Gọi và trả về kết quả của một phương thức của người giới thiệu proxy.
Nếu
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()07 là một proxy có người giới thiệu là
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()08 thì biểu thức
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()7
sẽ đánh giá biểu thức
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()8
Trong quá trình người quản lý.
Giá trị được trả về sẽ là bản sao kết quả của cuộc gọi hoặc proxy cho một đối tượng được chia sẻ mới - xem tài liệu cho đối số Phương thức_TO_TYPEID của
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()09.
Nếu một ngoại lệ được nâng lên bởi cuộc gọi, thì được tăng lại bởi
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()10. Nếu một số ngoại lệ khác được nâng lên trong quy trình của người quản lý thì điều này sẽ được chuyển đổi thành một ngoại lệ
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()11 và được nâng lên bởi
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()10.
Lưu ý cụ thể rằng một ngoại lệ sẽ được nêu ra nếu Phương thức không được phơi bày.
Một ví dụ về việc sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()10:
from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()9 _getValue ()()¶
Trả về một bản sao của người giới thiệu.
Nếu người giới thiệu là không thể chấp nhận được thì điều này sẽ tăng một ngoại lệ.
__repr __ ()()¶Trả về một đại diện của đối tượng proxy.
__str __ ()()¶Trả về đại diện của người giới thiệu.
Dọn dẹp¶
Một đối tượng proxy sử dụng một cuộc gọi lại yếu để khi nó được thu thập rác, nó tự hủy bỏ nó từ người quản lý sở hữu người giới thiệu của nó.
Một đối tượng được chia sẻ bị xóa khỏi quy trình Trình quản lý khi không còn bất kỳ proxy nào liên quan đến nó nữa.
Xử lý bể bơi
Người ta có thể tạo ra một nhóm các quy trình sẽ thực hiện các nhiệm vụ được gửi cho nó với lớp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4. classMultipRocessing.pool.pool ([Processes [, InfitionSizer [, initargs [, MaxTasksperChild [, bối cảnh]]]]]) multiprocessing.pool.Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])¶
Một đối tượng nhóm quy trình kiểm soát một nhóm các quy trình công nhân mà công việc có thể được gửi. Nó hỗ trợ kết quả không đồng bộ với thời gian chờ và gọi lại và có triển khai bản đồ song song.
Các quy trình là số lượng quy trình công nhân để sử dụng. Nếu các quy trình là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì số được trả về bởi import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()16 được sử dụng.
Nếu bộ khởi tạo không phải là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì mỗi quá trình công nhân sẽ gọi from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()52 khi bắt đầu.
MaxTasksperChild là số lượng nhiệm vụ mà một quy trình công nhân có thể hoàn thành trước khi nó thoát ra và được thay thế bằng quy trình công nhân mới, để cho phép các tài nguyên không sử dụng được giải phóng. MaxsksperChild mặc định là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32, có nghĩa là các quy trình của người lao động sẽ sống miễn là nhóm.Bối cảnh có thể được sử dụng để chỉ định bối cảnh được sử dụng để bắt đầu các quy trình của công nhân. Thông thường một nhóm được tạo bằng cách sử dụng hàm
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()20 hoặc phương thức
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()21 của một đối tượng ngữ cảnh. Trong cả hai trường hợp, bối cảnh được thiết lập phù hợp.
Lưu ý rằng các phương thức của đối tượng nhóm chỉ nên được gọi bởi quá trình tạo ra nhóm.
Cảnh báo
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()22 Các đối tượng có tài nguyên nội bộ cần được quản lý đúng (như bất kỳ tài nguyên nào khác) bằng cách sử dụng nhóm làm trình quản lý bối cảnh hoặc bằng cách gọi
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
74 và from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
70 theo cách thủ công. Việc không làm điều này có thể dẫn đến quá trình treo khi hoàn thiện.Lưu ý rằng không chính xác khi dựa vào người thu gom rác để phá hủy hồ bơi vì CPython không đảm bảo rằng bộ hoàn thiện của hồ bơi sẽ được gọi (xem
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()25 để biết thêm thông tin).not correct to rely on the garbage collector to destroy the pool as CPython does not assure that the finalizer of the pool will be called (see
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()25 for more information).
Mới trong phiên bản 3.2: MaxtasksperChildmaxtasksperchild
Mới trong phiên bản 3.4: Bối cảnhcontext
Ghi chú
Các quy trình của công nhân trong một
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4 thường sống trong toàn bộ thời gian của hàng đợi công việc nhóm. Một mẫu thường xuyên được tìm thấy trong các hệ thống khác (như Apache, Mod_WSGI, v.v.) để tài nguyên miễn phí do công nhân nắm giữ là cho phép một công nhân trong nhóm chỉ hoàn thành một lượng công việc đã thiết lập trước khi thoát ra, được dọn dẹp và một quy trình mới sinh ra để thay thế cái cũ. Đối số MaxTasksperChild cho
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4 hiển thị khả năng này cho người dùng cuối. Áp dụng (func [, args [, kwds]])(func[, args[, kwds]])¶
Gọi func với các đối số args và từ khóa đối số kwds. Nó chặn cho đến khi kết quả đã sẵn sàng. Với các khối này,
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()28 phù hợp hơn để thực hiện công việc song song. Ngoài ra, Func chỉ được thực hiện trong một trong những công nhân của nhóm. Ứng dụng_async (func [, args [, kwds [, gọi lại [, error_callback]]]])(func[, args[, kwds[, callback[, error_callback]]]])¶
Một biến thể của phương thức
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()29 trả về đối tượng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()30.
Nếu gọi lại được chỉ định thì nó phải là một cuộc gọi có thể gọi là chấp nhận một đối số duy nhất. Khi kết quả trở thành cuộc gọi lại sẵn sàng được áp dụng cho nó, đó là trừ khi cuộc gọi không thành công, trong trường hợp đó, ERROR_Callback được áp dụng thay thế.
Nếu error_callback được chỉ định thì nó sẽ là một cuộc gọi có thể gọi là chấp nhận một đối số duy nhất. Nếu hàm đích không thành công, thì error_callback được gọi với thể hiện ngoại lệ.
Các cuộc gọi lại sẽ hoàn thành ngay lập tức vì nếu không, luồng xử lý kết quả sẽ bị chặn.
Bản đồ (func, có thể lặp lại [, chunksize]) ¶(func, iterable[, chunksize])¶Tương đương song song của hàm tích hợp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31 (nó chỉ hỗ trợ một đối số có thể lặp lại, đối với nhiều lần lặp lại xem
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()32). Nó chặn cho đến khi kết quả đã sẵn sàng.
Phương pháp này cắt giảm có thể đi được thành một số khối mà nó gửi đến nhóm quy trình dưới dạng các nhiệm vụ riêng biệt. Kích thước (gần đúng) của các khối này có thể được chỉ định bằng cách đặt chunksize thành một số nguyên dương.
Lưu ý rằng nó có thể gây ra việc sử dụng bộ nhớ cao trong các lần lặp rất dài. Cân nhắc sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()33 hoặc
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()34 với tùy chọn phân đoạn rõ ràng để có hiệu quả tốt hơn. MAP_ASYNC (func, itable [, chrkksize [, callback [, error_callback]]])(func, iterable[, chunksize[, callback[, error_callback]]])¶
Một biến thể của phương thức
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31 trả về đối tượng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()30.
Nếu gọi lại được chỉ định thì nó phải là một cuộc gọi có thể gọi là chấp nhận một đối số duy nhất. Khi kết quả trở thành cuộc gọi lại sẵn sàng được áp dụng cho nó, đó là trừ khi cuộc gọi không thành công, trong trường hợp đó, ERROR_Callback được áp dụng thay thế.
Nếu error_callback được chỉ định thì nó sẽ là một cuộc gọi có thể gọi là chấp nhận một đối số duy nhất. Nếu hàm đích không thành công, thì error_callback được gọi với thể hiện ngoại lệ.
Các cuộc gọi lại sẽ hoàn thành ngay lập tức vì nếu không, luồng xử lý kết quả sẽ bị chặn.
Bản đồ (func, có thể lặp lại [, chunksize]) ¶(func, iterable[, chunksize])¶Tương đương song song của hàm tích hợp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31 (nó chỉ hỗ trợ một đối số có thể lặp lại, đối với nhiều lần lặp lại xem
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()32). Nó chặn cho đến khi kết quả đã sẵn sàng.
Phương pháp này cắt giảm có thể đi được thành một số khối mà nó gửi đến nhóm quy trình dưới dạng các nhiệm vụ riêng biệt. Kích thước (gần đúng) của các khối này có thể được chỉ định bằng cách đặt chunksize thành một số nguyên dương.much faster than using the default value of
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()39.
Lưu ý rằng nó có thể gây ra việc sử dụng bộ nhớ cao trong các lần lặp rất dài. Cân nhắc sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()33 hoặc
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()34 với tùy chọn phân đoạn rõ ràng để có hiệu quả tốt hơn. MAP_ASYNC (func, itable [, chrkksize [, callback [, error_callback]]])(func, iterable[, chunksize])¶
Một biến thể của phương thức
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31 trả về đối tượng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()30. IMAP (func, itable [, chunksize]) ¶(func, iterable[, chunksize])¶
Một phiên bản lười biếng hơn của
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31.
Đối số chunksize giống như phương pháp được sử dụng bởi phương pháp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31. Trong các lần lặp rất dài bằng cách sử dụng giá trị lớn cho chunksize có thể làm cho công việc hoàn thành nhanh hơn nhiều so với việc sử dụng giá trị mặc định là
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()39.
Ngoài ra, nếu Chunksize là import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
39 thì phương thức import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
41 của trình lặp được trả về bằng phương pháp import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
33 có tham số thời gian chờ tùy chọn: import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
43 sẽ tăng import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
44 nếu kết quả không thể được trả về trong vòng thời gian chờ.
Giống như
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()33 ngoại trừ việc đặt hàng các kết quả từ trình lặp được trả về nên được coi là tùy ý. (Chỉ khi chỉ có một quy trình công nhân là thứ tự được đảm bảo là chính xác.)
Ngoài ra, nếu Chunksize là import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
39 thì phương thức import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
41 của trình lặp được trả về bằng phương pháp import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
33 có tham số thời gian chờ tùy chọn: import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
43 sẽ tăng import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
44 nếu kết quả không thể được trả về trong vòng thời gian chờ.
Ngăn chặn thêm bất kỳ nhiệm vụ nào được gửi đến hồ bơi. Khi tất cả các nhiệm vụ đã được hoàn thành, các quy trình công nhân sẽ thoát.
chấm dứt () ¶()¶Dừng các quy trình công nhân ngay lập tức mà không hoàn thành công việc xuất sắc. Khi đối tượng hồ bơi được thu thập rác
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
70 sẽ được gọi ngay lập tức. tham gia()¶()¶Chờ các quá trình công nhân thoát ra. Người ta phải gọi
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
74 hoặc from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
70 trước khi sử dụng from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
47. classMultipRocessing.pool.asyncresult¶
multiprocessing.pool.AsyncResult¶Lớp kết quả được trả về bởi
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()55 và
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()56. Nhận ([thời gian chờ]) ¶([timeout])¶
Trả lại kết quả khi nó đến. Nếu thời gian chờ không phải là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 và kết quả không đến trong thời gian chờ vài giây thì import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()44 sẽ được nâng lên. Nếu cuộc gọi từ xa nêu ra một ngoại lệ thì ngoại lệ đó sẽ được phát lại bởi
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))52. Chờ ([thời gian chờ]) ¶([timeout])¶
Đợi cho đến khi kết quả có sẵn hoặc cho đến khi thời gian chờ vài giây trôi qua.
Sẵn sàng()¶()¶Trả lại liệu cuộc gọi đã hoàn thành.
thành công()¶()¶Trả lại liệu cuộc gọi hoàn thành mà không tăng ngoại lệ. Sẽ tăng
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
73 nếu kết quả chưa sẵn sàng.Thay đổi trong phiên bản 3.7: Nếu kết quả chưa sẵn sàng,
73 sẽ được nâng lên thay vì from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
from multiprocessing import Process
def f(name):
print('hello', name)
if __name__ == '__main__':
p = Process(target=f, args=('bob',))
p.start()
p.join()
78.If the result is not ready,
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
73 is raised instead of from multiprocessing import Process def f(name): print('hello', name) if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join()78.
Ví dụ sau đây cho thấy việc sử dụng một nhóm:
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()0
Người nghe và khách hàng
Thông thường việc truyền tin nhắn giữa các quá trình được thực hiện bằng cách sử dụng hàng đợi hoặc bằng cách sử dụng các đối tượng
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))08 được trả về bởi
from multiprocessing import Process, Lock def f(l, i): l.acquire() try: print('hello world', i) finally: l.release() if __name__ == '__main__': lock = Lock() for num in range(10): Process(target=f, args=(lock, num)).start()2.
Tuy nhiên, mô -đun
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()65 cho phép một số linh hoạt thêm. Về cơ bản, nó cung cấp một API theo định hướng thông điệp cấp cao để xử lý các ổ cắm hoặc các đường ống có tên Windows. Nó cũng có hỗ trợ cho xác thực tiêu hóa bằng mô -đun
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()66 và để bỏ phiếu nhiều kết nối cùng một lúc. Đa xử lý.Connection.Deliver_Challenge (Connection, AuthKey) ¶deliver_challenge(connection, authkey)¶
Gửi một thông báo được tạo ngẫu nhiên đến đầu kia của kết nối và chờ trả lời.
Nếu câu trả lời phù hợp với tiêu hóa của tin nhắn bằng AuthKey làm khóa thì một thông báo chào mừng được gửi đến đầu kia của kết nối. Nếu không
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()67 được nâng lên. Đa xử lý.connection.answer_challenge (Connection, AuthKey) ¶answer_challenge(connection, authkey)¶
Nhận tin nhắn, tính toán tiêu hóa của tin nhắn bằng AuthKey làm khóa, sau đó gửi lại Digest.
Nếu một tin nhắn chào mừng không được nhận, thì
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()67 sẽ được nêu ra. Đa xử lý.Connection.Client (địa chỉ [, gia đình [, authkey]]) ¶Client(address[, family[, authkey]])¶
Cố gắng thiết lập kết nối với trình nghe đang sử dụng địa chỉ địa chỉ, trả về
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))08.
Loại kết nối được xác định bằng đối số gia đình, nhưng điều này thường có thể được bỏ qua vì nó thường có thể được suy ra từ định dạng địa chỉ. (Xem định dạng địa chỉ)Address Formats)
Nếu AuthKey được đưa ra và không phải là không có, nó phải là một chuỗi byte và sẽ được sử dụng làm khóa bí mật cho một thách thức xác thực dựa trên HMAC. Không có xác thực được thực hiện nếu AuthKey không có.
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()67 được nâng lên nếu xác thực thất bại. Xem các khóa xác thực.Authentication keys. ClassMultipRocessing.Connection.Listener ([Địa chỉ [, gia đình [, Backlog [, AuthKey]]]])multiprocessing.connection.Listener([address[, family[, backlog[, authkey]]]])¶
Một trình bao bọc cho một ổ cắm bị ràng buộc hoặc đường ống có tên là ’lắng nghe cho các kết nối.
Địa chỉ là địa chỉ được sử dụng bởi ổ cắm bị ràng buộc hoặc đường ống được đặt tên của đối tượng người nghe.
Ghi chú
Nếu một địa chỉ ‘0,0.0.0, được sử dụng, địa chỉ sẽ không phải là điểm cuối có thể kết nối trên Windows. Nếu bạn yêu cầu điểm cuối có thể kết nối, bạn nên sử dụng ‘127.0.0.1.
Gia đình là loại ổ cắm (hoặc đường ống được đặt tên) để sử dụng. Đây có thể là một trong các chuỗi
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()71 (đối với ổ cắm TCP),
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()72 (đối với ổ cắm miền UNIX) hoặc
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()73 (đối với một đường ống có tên Windows). Trong số này chỉ những người đầu tiên được đảm bảo sẽ có sẵn. Nếu gia đình là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì gia đình được suy ra từ định dạng địa chỉ. Nếu địa chỉ cũng là from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì một mặc định được chọn. Mặc định này là gia đình được coi là nhanh nhất có sẵn. Xem các định dạng địa chỉ. Lưu ý rằng nếu gia đình là import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()72 và địa chỉ là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì ổ cắm sẽ được tạo trong thư mục tạm thời riêng tư được tạo bằng import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()78.Address Formats. Note that if family is
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()72 and address is
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 then the socket will be created in a private temporary
directory created using import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()78.
Nếu đối tượng người nghe sử dụng ổ cắm thì tồn đọng (1 theo mặc định) được chuyển đến phương thức
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()79 của ổ cắm sau khi nó bị ràng buộc.
Nếu AuthKey được đưa ra và không phải là không có, nó phải là một chuỗi byte và sẽ được sử dụng làm khóa bí mật cho một thách thức xác thực dựa trên HMAC. Không có xác thực được thực hiện nếu AuthKey không có.
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()67 được nâng lên nếu xác thực thất bại. Xem các khóa xác thực.Authentication keys. ClassMultipRocessing.Connection.Listener ([Địa chỉ [, gia đình [, Backlog [, AuthKey]]]])()¶
Một trình bao bọc cho một ổ cắm bị ràng buộc hoặc đường ống có tên là ’lắng nghe cho các kết nối.
gần()¶()¶Địa chỉ là địa chỉ được sử dụng bởi ổ cắm bị ràng buộc hoặc đường ống được đặt tên của đối tượng người nghe.
Đối tượng người nghe có các thuộc tính chỉ đọc sau:
địa chỉ¶¶Địa chỉ đang được sử dụng bởi đối tượng người nghe.
last_accepted¶¶Địa chỉ mà kết nối được chấp nhận cuối cùng đến. Nếu điều này không có sẵn thì đó là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32.
Đa xử lýwait(object_list, timeout=None)¶Đợi cho đến khi một đối tượng trong Object_List đã sẵn sàng. Trả về danh sách các đối tượng trong Object_List đã sẵn sàng. Nếu thời gian chờ là một float thì các khối cuộc gọi trong nhiều nhất là nhiều giây. Nếu thời gian chờ là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì nó sẽ chặn trong một khoảng thời gian không giới hạn. Một thời gian chờ âm tương đương với thời gian chờ không.Đối với cả UNIX và Windows, một đối tượng có thể xuất hiện trong object_list nếu nó là
một đối tượng
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))
08 có thể đọc được;một đối tượng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
86 được kết nối và có thể đọc được; hoặcthuộc tính
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
87 của đối tượngimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
9.
Một đối tượng kết nối hoặc ổ cắm đã sẵn sàng khi có sẵn dữ liệu để được đọc từ nó hoặc đầu kia đã được đóng.
UNIX: import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
89 gần như tương đương import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
90. Sự khác biệt là, nếu import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
91 bị gián đoạn bởi tín hiệu, nó có thể tăng from multiprocessing import Pool
def f(x):
return x*x
if __name__ == '__main__':
with Pool(5) as p:
print(p.map(f, [1, 2, 3]))
38 với số lỗi là import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
93, trong khi import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
94 sẽ không.:
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()89 almost equivalent
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()90. The difference is that, if
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()91 is interrupted by a signal, it can raise
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))38 with an error number of
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()93, whereas
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()94 will not.
Windows: Một mục trong Object_List phải là một tay cầm số nguyên có thể chờ đợi (theo định nghĩa được sử dụng bởi tài liệu của hàm Win32 import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
95) hoặc nó có thể là một đối tượng có phương thức import multiprocessing as mp
def foo(q):
q.put('hello')
if __name__ == '__main__':
mp.set_start_method('spawn')
q = mp.Queue()
p = mp.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
96 trả về tay cầm ổ cắm hoặc tay cầm ống. (Lưu ý rằng tay cầm ống và tay cầm ổ cắm không phải là tay cầm có thể chờ đợi.): An item in object_list must either be an integer handle which is waitable (according to the definition used by the documentation of the Win32 function
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()95) or it can be an object with a
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()96 method which returns a socket handle or pipe handle. (Note that pipe handles and socket handles are not waitable handles.)
Mới trong phiên bản 3.3.
Ví dụ
Mã máy chủ sau tạo một người nghe sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()97 làm khóa xác thực. Sau đó, nó chờ kết nối và gửi một số dữ liệu cho máy khách:
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()1
Mã sau kết nối với máy chủ và nhận một số dữ liệu từ máy chủ:
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()2
Mã sau sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()94 để chờ tin nhắn từ nhiều quy trình cùng một lúc:
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()3
Định dạng địa chỉ Or
Một địa chỉ
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
71 là một tuple của Mẫuimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
00 trong đó tên máy chủ là một chuỗi và cổng là một số nguyên.Địa chỉ
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
72 là một chuỗi đại diện cho tên tệp trên hệ thống tệp.Địa chỉ
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
73 là một chuỗi của mẫuimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
03. Để sử dụngimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
04 để kết nối với một đường ống được đặt tên trên máy tính từ xa có tên Servername, người ta nên sử dụng địa chỉ của biểu mẫuimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()
05 thay thế.
Lưu ý rằng bất kỳ chuỗi nào bắt đầu với hai dấu gạch chéo ngược được giả định theo mặc định là địa chỉ
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()73 thay vì địa chỉ
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()72.
Khóa xác thực
Khi một người sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()08, dữ liệu nhận được sẽ tự động không được giải thích. Thật không may, dữ liệu không được giải thích từ một nguồn không đáng tin cậy là một rủi ro bảo mật. Do đó,
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()09 và
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()04 Sử dụng mô -đun
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()66 để cung cấp xác thực tiêu hóa.
Khóa xác thực là chuỗi byte có thể được coi là mật khẩu: một khi kết nối được thiết lập, cả hai đầu sẽ yêu cầu bằng chứng rằng cái kia biết khóa xác thực. (Chứng minh rằng cả hai đầu đang sử dụng cùng một khóa không liên quan đến việc gửi khóa qua kết nối.)not involve sending the key over the connection.)
Nếu xác thực được yêu cầu nhưng không có khóa xác thực nào được chỉ định thì giá trị trả về của
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()43 được sử dụng (xem
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9). Giá trị này sẽ được tự động kế thừa bởi bất kỳ đối tượng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 nào mà quá trình hiện tại tạo ra. Điều này có nghĩa là (theo mặc định) tất cả các quy trình của chương trình đa quy trình sẽ chia sẻ một khóa xác thực duy nhất có thể được sử dụng khi thiết lập các kết nối giữa chúng.
Các phím xác thực phù hợp cũng có thể được tạo bằng cách sử dụng
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
60.Ghi nhật ký và
Một số hỗ trợ để ghi nhật ký có sẵn. Tuy nhiên, lưu ý rằng gói
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()16 không sử dụng các khóa được chia sẻ quy trình nên có thể (tùy thuộc vào loại xử lý) cho các tin nhắn từ các quy trình khác nhau để được trộn lẫn. đa xử lý.get_logger () ¶get_logger()¶
Trả về logger được sử dụng bởi
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8. Nếu cần thiết, một cái mới sẽ được tạo ra.
Khi được tạo lần đầu tiên, logger có cấp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()18 và không có trình xử lý mặc định. Các tin nhắn được gửi đến logger này sẽ không được tuyên truyền theo mặc định đến logger gốc.
Lưu ý rằng trên Windows Child, các quy trình sẽ chỉ kế thừa mức độ của bộ ghi nhật ký của quá trình cha mẹ - bất kỳ tùy chỉnh nào khác của logger sẽ không được kế thừa.
Đa xử lý.log_to_stderr (level = none) ¶log_to_stderr(level=None)¶Hàm này thực hiện một cuộc gọi đến
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()19 Nhưng ngoài việc trả về logger được tạo bởi get_logger, nó còn thêm một trình xử lý gửi đầu ra đến
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()20 bằng định dạng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()21. Bạn có thể sửa đổi
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()22 của logger bằng cách chuyển đối số
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()23.
Dưới đây là một phiên ví dụ với việc đăng nhập được bật:
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()4
Để biết một bảng đầy đủ các cấp độ ghi nhật ký, hãy xem mô -đun
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()16.
Mô -đun import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join() 25
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()25 sao chép API của
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 nhưng không khác gì một trình bao bọc xung quanh mô -đun
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9.
Cụ thể, hàm
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4 được cung cấp bởi
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()25 trả về một thể hiện là
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31, là một lớp con của
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4 hỗ trợ tất cả các cuộc gọi phương thức giống nhau nhưng sử dụng một nhóm các luồng công nhân thay vì các quy trình của công nhân. classMultipRocessing.pool.ThreadPool ([Processes [, Initalizer [, initArgs]]]) ¶ multiprocessing.pool.ThreadPool([processes[, initializer[, initargs]]])¶
Một đối tượng nhóm chủ đề kiểm soát một nhóm các chủ đề công nhân mà công việc có thể được gửi. Các trường hợp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31 tương thích giao diện hoàn toàn với các trường hợp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4 và tài nguyên của chúng cũng phải được quản lý đúng cách, bằng cách sử dụng nhóm làm trình quản lý ngữ cảnh hoặc bằng cách gọi
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
74 và from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
70 theo cách thủ công.Các quy trình là số lượng chủ đề công nhân để sử dụng. Nếu các quy trình là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì số được trả về bởi import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()16 được sử dụng.
Nếu bộ khởi tạo không phải là
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
32 thì mỗi quá trình công nhân sẽ gọi from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()52 khi bắt đầu.
Không giống như
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4, MaxTasksperChild và bối cảnh không thể được cung cấp.
Ghi chú
A
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()31 có chung giao diện vớiimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4, được thiết kế xung quanh một nhóm quy trình và có trước khi giới thiệu mô -đunimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8. Do đó, nó kế thừa một số hoạt động không có ý nghĩa đối với một nhóm được hỗ trợ bởi các chủ đề và nó có loại riêng để thể hiện trạng thái của các công việc không đồng bộ,import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()30, không được bất kỳ thư viện nào khác hiểu.Người dùng thường thích sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()46, có giao diện đơn giản hơn được thiết kế xung quanh các luồng từ đầu và trả về các trường hợpimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()47 tương thích với nhiều thư viện khác, bao gồmimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()48.
Hướng dẫn lập trình
Có một số hướng dẫn và thành ngữ nhất định nên được tuân thủ khi sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8.
Tất cả các phương pháp bắt đầu
Sau đây áp dụng cho tất cả các phương thức bắt đầu.
Tránh trạng thái chia sẻ
Càng xa càng tốt, người ta nên cố gắng tránh chuyển một lượng lớn dữ liệu giữa các quy trình.
Có lẽ tốt nhất là sử dụng hàng đợi hoặc đường ống để giao tiếp giữa các quy trình thay vì sử dụng các nguyên thủy đồng bộ hóa cấp thấp hơn.
Khả năng chọn
Đảm bảo rằng các đối số cho các phương thức của proxy là có thể chọn được.
Chủ đề an toàn của proxy
Không sử dụng một đối tượng proxy từ nhiều hơn một luồng trừ khi bạn bảo vệ nó bằng khóa.
(Không bao giờ có vấn đề với các quy trình khác nhau sử dụng cùng một proxy.)
Tham gia các quá trình zombie
Trên Unix khi một quá trình kết thúc nhưng chưa được tham gia, nó trở thành một thây ma. Không bao giờ có rất nhiều vì mỗi lần một quá trình mới bắt đầu (hoặc
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()50 được gọi) Tất cả các quy trình đã hoàn thành chưa được tham gia sẽ được tham gia. Cũng gọi một quá trình đã hoàn thành, ____ ____651 sẽ tham gia vào quá trình. Mặc dù vậy, có lẽ là thực hành tốt để tham gia rõ ràng tất cả các quá trình mà bạn bắt đầu.
Tốt hơn để thừa kế hơn Pickle/Unpickle
Khi sử dụng các phương thức bắt đầu sinh sản hoặc Forkerver, nhiều loại từ
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 cần phải được chọn để các quá trình con có thể sử dụng chúng. Tuy nhiên, người ta thường nên tránh gửi các đối tượng được chia sẻ đến các quy trình khác bằng đường ống hoặc hàng đợi. Thay vào đó, bạn nên sắp xếp chương trình để một quy trình cần truy cập vào một tài nguyên được chia sẻ được tạo ở nơi khác có thể kế thừa nó từ một quy trình tổ tiên.
Tránh chấm dứt các quá trình
Sử dụng phương pháp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()53 để dừng quy trình có thể gây ra bất kỳ tài nguyên chung nào (như khóa, semaphores, đường ống và hàng đợi) hiện đang được sử dụng bởi quy trình để bị hỏng hoặc không có sẵn các quy trình khác.Do đó, có lẽ tốt nhất là chỉ xem xét sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()53 trên các quy trình không bao giờ sử dụng bất kỳ tài nguyên chung nào.
Tham gia các quy trình sử dụng hàng đợi
Hãy nhớ rằng một quá trình đã đặt các vật phẩm vào hàng đợi sẽ đợi trước khi chấm dứt cho đến khi tất cả các vật phẩm được đệm được cung cấp bởi chủ đề nguồn cấp dữ liệu trên đường ống bên dưới. (Quá trình con có thể gọi phương thức
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()55 của hàng đợi để tránh hành vi này.)Điều này có nghĩa là bất cứ khi nào bạn sử dụng hàng đợi, bạn cần đảm bảo rằng tất cả các mục đã được đặt vào hàng đợi cuối cùng sẽ được gỡ bỏ trước khi quá trình được tham gia. Nếu không, bạn không thể chắc chắn rằng các quy trình đã đặt các mục vào hàng đợi sẽ chấm dứt. Cũng nên nhớ rằng các quy trình không thuộc Daemonic sẽ được tham gia tự động.
Một ví dụ sẽ bế tắc như sau:
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()5Một bản sửa lỗi ở đây sẽ là trao đổi hai dòng cuối cùng (hoặc đơn giản là loại bỏ dòng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()56).
Rõ ràng chuyển tài nguyên cho các quá trình trẻ em
Trên UNIX sử dụng phương thức bắt đầu của Fork, quy trình con có thể sử dụng tài nguyên được chia sẻ được tạo trong quy trình cha bằng cách sử dụng tài nguyên toàn cầu. Tuy nhiên, tốt hơn là chuyển đối tượng như một đối số cho hàm tạo cho quá trình con.
Ngoài việc tạo mã (có khả năng) tương thích với Windows và các phương thức bắt đầu khác, điều này cũng đảm bảo rằng miễn là quá trình con còn sống, đối tượng sẽ không được thu thập rác trong quy trình cha. Điều này có thể quan trọng nếu một số tài nguyên được giải phóng khi đối tượng được thu thập rác trong quy trình cha.
Vì vậy, ví dụ
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()6nên được viết lại là
from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()7
Cẩn thận với việc thay thế
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()57 bằng một tệp như đối tượng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()8 ban đầu được gọi là vô điều kiện:from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()8Trong phương pháp
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()59-điều này dẫn đến các vấn đề với các quy trình trong quá trình. Điều này đã được thay đổi thành:from multiprocessing import Process import os def info(title): print(title) print('module name:', __name__) print('parent process:', os.getppid()) print('process id:', os.getpid()) def f(name): info('function f') print('hello', name) if __name__ == '__main__': info('main line') p = Process(target=f, args=('bob',)) p.start() p.join()9Giải quyết vấn đề cơ bản của các quá trình va chạm với nhau dẫn đến lỗi mô tả tệp xấu, nhưng đưa ra một mối nguy hiểm tiềm tàng cho các ứng dụng thay thế
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()60 bằng một đối tượng giống như tệp của Google với bộ đệm đầu ra. Nguy hiểm này là nếu nhiều quá trình gọi74 trên đối tượng giống như tệp này, nó có thể dẫn đến cùng một dữ liệu được chuyển đến đối tượng nhiều lần, dẫn đến tham nhũng.from datetime import datetime, timedelta import heapq # just holds a function, its arguments, and when we want it to execute. class TimeoutFunction: def __init__(self, function, timeout, *args): self.function = function self.args = args self.startTime = datetime.now() + timedelta(0,0,0,timeout) def execute(self): self.function(*self.args) # A "todo" list for all the TimeoutFunctions we want to execute in the future # They are sorted in the order they should be executed, thanks to heapq class TodoList: def __init__(self): self.todo = [] def addToList(self, tFunction): heapq.heappush(self.todo, (tFunction.startTime, tFunction)) def executeReadyFunctions(self): if len(self.todo) > 0: tFunction = heapq.heappop(self.todo)[1] while tFunction and datetime.now() > tFunction.startTime: #execute all the functions that are ready tFunction.execute() if len(self.todo) > 0: tFunction = heapq.heappop(self.todo)[1] else: tFunction = None if tFunction: #this one's not ready yet, push it back on heapq.heappush(self.todo, (tFunction.startTime, tFunction)) def singleArgFunction(x): print str(x) def multiArgFunction(x, y): #Demonstration of passing multiple-argument functions print str(x*y) # Make some TimeoutFunction objects # timeout is in milliseconds a = TimeoutFunction(singleArgFunction, 1000, 20) b = TimeoutFunction(multiArgFunction, 2000, *(11,12)) c = TimeoutFunction(quit, 3000, None) todoList = TodoList() todoList.addToList(a) todoList.addToList(b) todoList.addToList(c) while True: todoList.executeReadyFunctions()
Nếu bạn viết một đối tượng giống như tệp và thực hiện bộ nhớ đệm của riêng bạn, bạn có thể làm cho nó an toàn bằng cách lưu trữ PID bất cứ khi nào bạn nối vào bộ đệm và loại bỏ bộ đệm khi PID thay đổi. Ví dụ:
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()0Để biết thêm thông tin, xem BPO-5155, BPO-5313 và BPO-5331
Phương pháp bắt đầu sinh sản và forkerver
Có một vài hạn chế thêm mà don don áp dụng cho phương pháp bắt đầu của ngã ba.
Nhiều khả năng lựa chọn hơn
Đảm bảo rằng tất cả các đối số cho
42 đều có thể chọn được. Ngoài ra, nếu bạn phân lớpfrom datetime import datetime, timedelta import heapq # just holds a function, its arguments, and when we want it to execute. class TimeoutFunction: def __init__(self, function, timeout, *args): self.function = function self.args = args self.startTime = datetime.now() + timedelta(0,0,0,timeout) def execute(self): self.function(*self.args) # A "todo" list for all the TimeoutFunctions we want to execute in the future # They are sorted in the order they should be executed, thanks to heapq class TodoList: def __init__(self): self.todo = [] def addToList(self, tFunction): heapq.heappush(self.todo, (tFunction.startTime, tFunction)) def executeReadyFunctions(self): if len(self.todo) > 0: tFunction = heapq.heappop(self.todo)[1] while tFunction and datetime.now() > tFunction.startTime: #execute all the functions that are ready tFunction.execute() if len(self.todo) > 0: tFunction = heapq.heappop(self.todo)[1] else: tFunction = None if tFunction: #this one's not ready yet, push it back on heapq.heappush(self.todo, (tFunction.startTime, tFunction)) def singleArgFunction(x): print str(x) def multiArgFunction(x, y): #Demonstration of passing multiple-argument functions print str(x*y) # Make some TimeoutFunction objects # timeout is in milliseconds a = TimeoutFunction(singleArgFunction, 1000, 20) b = TimeoutFunction(multiArgFunction, 2000, *(11,12)) c = TimeoutFunction(quit, 3000, None) todoList = TodoList() todoList.addToList(a) todoList.addToList(b) todoList.addToList(c) while True: todoList.executeReadyFunctions()
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()9 thì hãy đảm bảo rằng các phiên bản sẽ có thể chọn được khi phương thứcimport multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()64 được gọi.
Biến toàn cầu
Hãy nhớ rằng nếu mã chạy trong một quy trình con cố gắng truy cập biến toàn cầu, thì giá trị mà nó nhìn thấy (nếu có) có thể không giống như giá trị trong quy trình cha mẹ tại thời điểm
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()64 được gọi.Tuy nhiên, các biến toàn cầu chỉ là các hằng số cấp mô -đun không gây ra vấn đề gì.
Nhập an toàn mô -đun chính
Đảm bảo rằng mô -đun chính có thể được nhập một cách an toàn bởi một trình thông dịch Python mới mà không gây ra các tác dụng phụ ngoài ý muốn (như vậy là một quy trình mới).
Ví dụ: sử dụng phương thức bắt đầu Spawn hoặc Forkerver Chạy mô -đun sau sẽ không thành công với
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))80:import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()1Thay vào đó, người ta nên bảo vệ điểm nhập cảnh trên mạng của chương trình bằng cách sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()67 như sau:import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()2(Dòng
from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': with Pool(5) as p: print(p.map(f, [1, 2, 3]))79 có thể được bỏ qua nếu chương trình sẽ được chạy bình thường thay vì đóng băng.)Điều này cho phép trình thông dịch Python mới được sinh ra để nhập mô -đun một cách an toàn và sau đó chạy chức năng mô -đun
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()69.Các hạn chế tương tự được áp dụng nếu một nhóm hoặc người quản lý được tạo trong mô -đun chính.
Ví dụ;
Trình diễn cách tạo và sử dụng người quản lý và proxy tùy chỉnh:
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()3
Sử dụng
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': ctx = mp.get_context('spawn') q = ctx.Queue() p = ctx.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4:
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()4
Một ví dụ cho thấy cách sử dụng hàng đợi để cung cấp các tác vụ cho một bộ sưu tập các quy trình của công nhân và thu thập kết quả:
import multiprocessing as mp def foo(q): q.put('hello') if __name__ == '__main__': mp.set_start_method('spawn') q = mp.Queue() p = mp.Process(target=foo, args=(q,)) p.start() print(q.get()) p.join()5