Quá trình tham gia () trong Python là gì?

Đó là việc sử dụng hai hoặc nhiều đơn vị CPU trong một hệ thống máy tính. Đó là cách tiếp cận tốt nhất để khai thác hết tiềm năng từ phần cứng của chúng tôi bằng cách tận dụng toàn bộ số lõi CPU có sẵn trong hệ thống máy tính của chúng tôi

đa luồng

Đó là khả năng CPU quản lý việc sử dụng hệ điều hành bằng cách thực thi đồng thời nhiều luồng. Ý tưởng chính của đa luồng là đạt được tính song song bằng cách chia một quy trình thành nhiều luồng

Bảng sau đây cho thấy một số khác biệt quan trọng giữa chúng -

Đa xử lýĐa chương trìnhĐa xử lý đề cập đến việc xử lý nhiều quy trình cùng một lúc bởi nhiều CPU. Đa chương trình giữ một số chương trình trong bộ nhớ chính cùng một lúc và thực thi chúng đồng thời sử dụng một CPU. Nó sử dụng nhiều CPU. Nó sử dụng CPU đơn. Nó cho phép xử lý song song. Chuyển ngữ cảnh diễn ra. Mất ít thời gian hơn để xử lý các công việc. Mất nhiều thời gian hơn để xử lý công việc. Nó tạo điều kiện sử dụng hiệu quả nhiều thiết bị của hệ thống máy tính. Kém hiệu quả hơn đa xử lý. Thường đắt hơn. Những hệ thống như vậy ít tốn kém hơn

Loại bỏ tác động của khóa phiên dịch toàn cầu [GIL]

Trong khi làm việc với các ứng dụng đồng thời, có một hạn chế trong Python được gọi là GIL [Khóa phiên dịch toàn cầu]. GIL không bao giờ cho phép chúng tôi sử dụng nhiều lõi CPU và do đó chúng tôi có thể nói rằng không có luồng thực sự nào trong Python. GIL là mutex – khóa loại trừ lẫn nhau, giúp mọi thứ trở nên an toàn. Nói cách khác, chúng ta có thể nói rằng GIL ngăn nhiều luồng thực thi mã Python song song. Khóa chỉ có thể được giữ bởi một luồng tại một thời điểm và nếu chúng ta muốn thực thi một luồng thì trước tiên nó phải lấy khóa

Với việc sử dụng đa xử lý, chúng ta có thể bỏ qua giới hạn do GIL gây ra một cách hiệu quả –

• Bằng cách sử dụng đa xử lý, chúng tôi đang sử dụng khả năng của nhiều quy trình và do đó chúng tôi đang sử dụng nhiều phiên bản của GIL

• Do đó, không có giới hạn nào trong việc thực thi mã byte của một chuỗi trong các chương trình của chúng tôi tại bất kỳ thời điểm nào

Quy trình bắt đầu trong Python

Ba phương thức sau đây có thể được sử dụng để bắt đầu một quy trình trong Python trong mô-đun đa xử lý –

Tạo một quy trình với Fork

Lệnh rẽ nhánh là một lệnh tiêu chuẩn được tìm thấy trong UNIX. Nó được sử dụng để tạo các tiến trình mới gọi là các tiến trình con. Tiến trình con này chạy đồng thời với tiến trình được gọi là tiến trình cha. Các tiến trình con này cũng giống với các tiến trình cha của chúng và kế thừa tất cả các tài nguyên có sẵn của tiến trình cha. Các cuộc gọi hệ thống sau đây được sử dụng trong khi tạo một quy trình với Fork -

• fork[] - Đây là một cuộc gọi hệ thống thường được triển khai trong kernel. Nó được sử dụng để tạo một bản sao của quá trình. p>

• getpid[] − Lệnh gọi hệ thống này trả về ID tiến trình [PID] của tiến trình gọi

Thí dụ

Ví dụ tập lệnh Python sau đây sẽ giúp bạn hiểu cách tạo một tiến trình con mới và lấy PID của các tiến trình cha và con −

import os

def child[]:
   n = os.fork[]
   
   if n > 0:
      print["PID of Parent process is : ", os.getpid[]]

   else:
      print["PID of Child process is : ", os.getpid[]]
child[]

đầu ra

PID of Parent process is : 25989
PID of Child process is : 25990

Tạo một quy trình với Spawn

Sinh sản có nghĩa là bắt đầu một cái gì đó mới. Do đó, sinh ra một tiến trình có nghĩa là việc tạo ra một tiến trình mới bởi một tiến trình cha. Tiến trình cha tiếp tục thực hiện không đồng bộ hoặc đợi cho đến khi tiến trình con kết thúc việc thực hiện. Thực hiện theo các bước sau để sinh ra một quy trình -

• Nhập mô-đun đa xử lý

• Tạo quy trình đối tượng

• Bắt đầu hoạt động của quy trình bằng cách gọi phương thức start[]

• Đợi cho đến khi quá trình hoàn thành công việc của nó và thoát bằng cách gọi phương thức nối []

Thí dụ

Ví dụ sau về tập lệnh Python giúp sinh ra ba quy trình

import multiprocessing

def spawn_process[i]:
   print ['This is process: %s' %i]
   return

if __name__ == '__main__':
   Process_jobs = []
   for i in range[3]:
   p = multiprocessing.Process[target = spawn_process, args = [i,]]
      Process_jobs.append[p]
   p.start[]
   p.join[]

đầu ra

This is process: 0
This is process: 1
This is process: 2

Tạo một quy trình với Forkserver

Cơ chế forkserver chỉ khả dụng trên những nền tảng UNIX đã chọn hỗ trợ chuyển bộ mô tả tệp qua Unix Pipes. Xem xét các điểm sau để hiểu hoạt động của cơ chế Forkserver –

• Một máy chủ được khởi tạo khi sử dụng cơ chế Forkserver để bắt đầu quy trình mới

• Sau đó, máy chủ nhận lệnh và xử lý tất cả các yêu cầu tạo quy trình mới

• Để tạo một quy trình mới, chương trình python của chúng tôi sẽ gửi yêu cầu tới Forkserver và nó sẽ tạo một quy trình cho chúng tôi

• Cuối cùng, chúng ta có thể sử dụng quy trình mới được tạo này trong các chương trình của mình

Quy trình daemon trong Python

Mô-đun đa xử lý Python cho phép chúng ta có các quy trình trình nền thông qua tùy chọn trình nền của nó. Các quy trình daemon hoặc các quy trình đang chạy trong nền tuân theo khái niệm tương tự như các luồng daemon. Để thực thi quy trình ở chế độ nền, chúng ta cần đặt cờ daemonic thành true. Quá trình daemon sẽ tiếp tục chạy miễn là quá trình chính đang thực thi và nó sẽ chấm dứt sau khi kết thúc quá trình thực thi hoặc khi chương trình chính bị hủy

Thí dụ

Ở đây, chúng tôi đang sử dụng cùng một ví dụ như được sử dụng trong chủ đề daemon. Sự khác biệt duy nhất là thay đổi mô-đun từ đa luồng thành đa xử lý và đặt cờ daemonic thành true. Tuy nhiên, sẽ có sự thay đổi về đầu ra như hình bên dưới -

import multiprocessing
import time

def nondaemonProcess[]:
   print["starting my Process"]
   time.sleep[8]
   print["ending my Process"]
def daemonProcess[]:
   while True:
   print["Hello"]
   time.sleep[2]
if __name__ == '__main__':
   nondaemonProcess = multiprocessing.Process[target = nondaemonProcess]
   daemonProcess = multiprocessing.Process[target = daemonProcess]
   daemonProcess.daemon = True
   nondaemonProcess.daemon = False
   daemonProcess.start[]
   nondaemonProcess.start[]

đầu ra

starting my Process
ending my Process

Đầu ra khác khi so sánh với đầu ra được tạo bởi các luồng daemon, bởi vì quá trình ở chế độ không có daemon có đầu ra. Do đó, quá trình daemon tự động kết thúc sau khi các chương trình chính kết thúc để tránh sự tồn tại của các quá trình đang chạy

Chấm dứt các quy trình trong Python

Chúng ta có thể hủy hoặc kết thúc một tiến trình ngay lập tức bằng cách sử dụng phương thức term[]. Chúng tôi sẽ sử dụng phương thức này để kết thúc tiến trình con đã được tạo với sự trợ giúp của hàm, ngay trước khi hoàn thành việc thực hiện

Thí dụ

import multiprocessing
import time
def Child_process[]:
   print ['Starting function']
   time.sleep[5]
   print ['Finished function']
P = multiprocessing.Process[target = Child_process]
P.start[]
print["My Process has terminated, terminating main thread"]
print["Terminating Child Process"]
P.terminate[]
print["Child Process successfully terminated"]

đầu ra

My Process has terminated, terminating main thread
Terminating Child Process
Child Process successfully terminated

Đầu ra cho thấy chương trình kết thúc trước khi thực thi tiến trình con đã được tạo với sự trợ giúp của hàm Child_ process[]. Điều này ngụ ý rằng quá trình con đã được kết thúc thành công

Xác định quy trình hiện tại trong Python

Mọi quy trình trong hệ điều hành đều có danh tính quy trình được gọi là PID. Trong Python, chúng ta có thể tìm ra PID của quy trình hiện tại với sự trợ giúp của lệnh sau –

________số 8_______

Thí dụ

Ví dụ về tập lệnh Python sau đây giúp tìm ra PID của quy trình chính cũng như PID của quy trình con −

import multiprocessing
import time
def Child_process[]:
   print["PID of Child Process is: {}".format[multiprocessing.current_process[].pid]]
print["PID of Main process is: {}".format[multiprocessing.current_process[].pid]]
P = multiprocessing.Process[target=Child_process]
P.start[]
P.join[]

đầu ra

PID of Parent process is : 25989
PID of Child process is : 25990

0

Sử dụng một quy trình trong lớp con

Chúng ta có thể tạo các luồng bằng cách phân loại luồng. lớp chủ đề. Ngoài ra, chúng ta cũng có thể tạo các tiến trình bằng cách phân lớp con các tiến trình đa xử lý. lớp quy trình. Để sử dụng một quy trình trong lớp con, chúng ta cần xem xét các điểm sau -

• Chúng ta cần định nghĩa một lớp con mới của lớp Process

• Chúng ta cần ghi đè lớp _init_[self [,args] ]

• Chúng ta cần ghi đè phương thức run[self [,args] ] để triển khai Quy trình nào

• Chúng ta cần bắt đầu quá trình bằng cách gọi phương thức start[]

Thí dụ

PID of Parent process is : 25989
PID of Child process is : 25990

1

đầu ra

PID of Parent process is : 25989
PID of Child process is : 25990

2

Mô-đun đa xử lý Python – Pool Class

Nếu chúng ta nói về các tác vụ xử lý song song đơn giản trong các ứng dụng Python của mình, thì mô-đun đa xử lý cung cấp cho chúng ta lớp Pool. Các phương thức sau của lớp Pool có thể được sử dụng để tăng số lượng tiến trình con trong chương trình chính của chúng ta

phương pháp áp dụng []

Phương pháp này tương tự như phương pháp. phương thức đệ trình [] của. ThreadPoolExecutor. Nó chặn cho đến khi kết quả sẵn sàng

phương thức apply_async[]

Khi chúng tôi cần thực hiện song song các tác vụ của mình thì chúng tôi cần sử dụng phương thức apply_async[] để gửi tác vụ tới nhóm. Đây là một hoạt động không đồng bộ sẽ không khóa luồng chính cho đến khi tất cả các tiến trình con được thực thi

phương thức map[]

Giống như phương thức apply[], nó cũng chặn cho đến khi có kết quả. Nó tương đương với chức năng map[] tích hợp chia dữ liệu có thể lặp lại thành một số khối và gửi đến nhóm quy trình dưới dạng các tác vụ riêng biệt

phương thức map_async[]

Nó là một biến thể của phương thức map[] vì apply_async[] là phương thức apply[]. Nó trả về một đối tượng kết quả. Khi kết quả sẵn sàng, một khả năng gọi được áp dụng cho nó. Có thể gọi được phải được hoàn thành ngay lập tức;

Thí dụ

Ví dụ sau sẽ giúp bạn triển khai nhóm quy trình để thực hiện song song. Một phép tính đơn giản về bình phương của số đã được thực hiện bằng cách áp dụng hàm square[] thông qua đa xử lý. phương pháp nhóm. Sau đó bơi. map[] đã được sử dụng để gửi 5, vì đầu vào là danh sách các số nguyên từ 0 đến 4. Kết quả sẽ được lưu trữ trong p_outputs và nó được in ra

Quy trình Tham gia có nghĩa là gì?

Tham gia nhóm [] là gì?

Khi nào sử dụng Python đa xử lý?

Nhóm quy trình trong Python là gì?