Xử lý thông tin liên lạc

Thông tin liên lạc giữa các quá trình có nghĩa là trao đổi dữ liệu giữa các quá trình. Cần phải trao đổi dữ liệu giữa các quy trình để phát triển ứng dụng song song. Sơ đồ sau cho thấy các cơ chế giao tiếp khác nhau để đồng bộ hóa giữa nhiều quy trình con -

Các cơ chế giao tiếp khác nhau

Trong phần này, chúng ta sẽ tìm hiểu về các cơ chế giao tiếp khác nhau. Các cơ chế được mô tả dưới đây:

Hàng đợi

Hàng đợi có thể được sử dụng với các chương trình đa quy trình. Lớp hàng đợi củamultiprocessing mô-đun tương tự như Queue.Queuelớp học. Do đó, có thể sử dụng cùng một API.Multiprocessing.Queue cung cấp cho chúng ta một cơ chế giao tiếp FIFO (nhập trước xuất trước) an toàn theo luồng và quy trình giữa các quy trình.

Thí dụ

Sau đây là một ví dụ đơn giản được lấy từ tài liệu chính thức của python về đa xử lý để hiểu khái niệm về lớp Hàng đợi của đa xử lý.

from multiprocessing import Process, Queue
import queue
import random
def f(q):
   q.put([42, None, 'hello'])
def main():
   q = Queue()
   p = Process(target = f, args = (q,))
   p.start()
   print (q.get())
if __name__ == '__main__':
   main()

Đầu ra

[42, None, 'hello']

Đường ống

Nó là một cấu trúc dữ liệu, được sử dụng để giao tiếp giữa các quy trình trong các chương trình đa quy trình. Hàm Pipe () trả về một cặp đối tượng kết nối được kết nối bằng một đường ống theo mặc định là song công (hai chiều). Nó hoạt động theo cách sau:

Nó trả về một cặp đối tượng kết nối đại diện cho hai đầu của đường ống.
Mọi đối tượng đều có hai phương thức - send() và recv(), để giao tiếp giữa các quy trình.

Thí dụ

Sau đây là một ví dụ đơn giản được lấy từ tài liệu chính thức của python về đa xử lý để hiểu khái niệm về Pipe() chức năng của đa xử 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())
   p.join()

Đầu ra

[42, None, 'hello']

Giám đốc

Trình quản lý là một lớp mô-đun đa xử lý cung cấp cách điều phối thông tin được chia sẻ giữa tất cả người dùng của nó. Đối tượng người quản lý kiểm soát một quy trình máy chủ, quy trình này quản lý các đối tượng được chia sẻ và cho phép các quy trình khác thao tác chúng. Nói cách khác, các nhà quản lý cung cấp một cách để tạo ra dữ liệu có thể được chia sẻ giữa các quy trình khác nhau. Sau đây là các thuộc tính khác nhau của đối tượng manager:

Thuộc tính chính của manager là kiểm soát một tiến trình máy chủ, quản lý các đối tượng được chia sẻ.
Một thuộc tính quan trọng khác là cập nhật tất cả các đối tượng được chia sẻ khi bất kỳ quá trình nào sửa đổi nó.

Thí dụ

Sau đây là một ví dụ sử dụng đối tượng manager để tạo một bản ghi danh sách trong quy trình máy chủ và sau đó thêm một bản ghi mới vào danh sách đó.

import multiprocessing

def print_records(records):
   for record in records:
      print("Name: {0}\nScore: {1}\n".format(record[0], record[1]))

def insert_record(record, records):
   records.append(record)
      print("A New record is added\n")

if __name__ == '__main__':
   with multiprocessing.Manager() as manager:

      records = manager.list([('Computers', 1), ('Histoty', 5), ('Hindi',9)])
      new_record = ('English', 3)

      p1 = multiprocessing.Process(target = insert_record, args = (new_record, records))
      p2 = multiprocessing.Process(target = print_records, args = (records,))
	  p1.start()
      p1.join()
      p2.start()
      p2.join()

Đầu ra

A New record is added

Name: Computers
Score: 1

Name: Histoty
Score: 5

Name: Hindi
Score: 9

Name: English
Score: 3

Khái niệm về Không gian tên trong Trình quản lý

Lớp quản lý đi kèm với khái niệm không gian tên, là một phương pháp nhanh chóng để chia sẻ một số thuộc tính trên nhiều quy trình. Không gian tên không có bất kỳ phương thức công cộng nào có thể được gọi, nhưng chúng có các thuộc tính có thể ghi.

Thí dụ

Ví dụ tập lệnh Python sau đây giúp chúng tôi sử dụng không gian tên để chia sẻ dữ liệu giữa quy trình chính và quy trình con -

import multiprocessing

def Mng_NaSp(using_ns):

   using_ns.x +=5
   using_ns.y *= 10

if __name__ == '__main__':
   manager = multiprocessing.Manager()
   using_ns = manager.Namespace()
   using_ns.x = 1
   using_ns.y = 1

   print ('before', using_ns)
   p = multiprocessing.Process(target = Mng_NaSp, args = (using_ns,))
   p.start()
   p.join()
   print ('after', using_ns)

Đầu ra

before Namespace(x = 1, y = 1)
after Namespace(x = 6, y = 10)

Ctypes-Mảng và Giá trị

Mô-đun đa xử lý cung cấp các đối tượng Mảng và Giá trị để lưu trữ dữ liệu trong bản đồ bộ nhớ dùng chung. Array là một mảng ctypes được cấp phát từ bộ nhớ dùng chung và Value là một đối tượng ctypes được cấp phát từ bộ nhớ dùng chung.

Cùng với, nhập Quy trình, Giá trị, Mảng từ xử lý đa.

Thí dụ

Sau script Python là một ví dụ được lấy từ tài liệu python để sử dụng Ctypes Array và Value để chia sẻ một số dữ liệu giữa các quy trình.

def f(n, a):
   n.value = 3.1415927
   for i in range(len(a)):
   a[i] = -a[i]

if __name__ == '__main__':
   num = Value('d', 0.0)
   arr = Array('i', range(10))

   p = Process(target = f, args = (num, arr))
   p.start()
   p.join()
   print (num.value)
   print (arr[:])

Đầu ra

3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

Giao tiếp các quy trình tuần tự (CSP)

CSP được sử dụng để minh họa sự tương tác của hệ thống với các hệ thống khác có mô hình đồng thời. CSP là một khuôn khổ để viết đồng thời hoặc chương trình thông qua việc truyền thông điệp và do đó nó có hiệu quả để mô tả đồng thời.

Thư viện Python - PyCSP

Để triển khai các nguyên thủy cốt lõi được tìm thấy trong CSP, Python có một thư viện được gọi là PyCSP. Nó giữ cho việc triển khai rất ngắn gọn và dễ đọc để có thể hiểu rất dễ dàng. Sau đây là mạng quy trình cơ bản của PyCSP -

Trong mạng quy trình PyCSP ở trên, có hai quy trình - Quy trình 1 và Quy trình 2. Các quy trình này giao tiếp bằng cách truyền thông điệp qua hai kênh - kênh 1 và kênh 2.

Cài đặt PyCSP

Với sự trợ giúp của lệnh sau, chúng ta có thể cài đặt thư viện Python PyCSP -

pip install PyCSP

Thí dụ

Tập lệnh Python sau đây là một ví dụ đơn giản để chạy hai tiến trình song song với nhau. Nó được thực hiện với sự trợ giúp của con trăn PyCSP libabary -

from pycsp.parallel import *
import time
@process
def P1():
   time.sleep(1)
   print('P1 exiting')
@process
def P2():
   time.sleep(1)
   print('P2 exiting')
def main():
   Parallel(P1(), P2())
   print('Terminating')
if __name__ == '__main__':
   main()

Trong tập lệnh trên, hai chức năng cụ thể là P1 và P2 đã được tạo ra và sau đó được trang trí bằng @process để chuyển đổi chúng thành các quy trình.

Đầu ra

P2 exiting
P1 exiting
Terminating