programming python Multiprocessing Python Parallel Python Process in Python

Hướng dẫn how do you communicate between processes in python? - làm thế nào để bạn giao tiếp giữa các quy trình trong python?

Đa xử lý trong Python | Đặt các bài viết thứ 1 thảo luận về khái niệm chia sẻ dữ liệu và truyền tin nhắn giữa các quy trình trong khi sử dụng mô -đun đa xử lý trong Python.in Multiprocessing, bất kỳ quá trình mới được tạo sẽ làm sau:
These articles discusses the concept of data sharing and message passing between processes while using multiprocessing module in Python.
In multiprocessing, any newly created process will do following:

  • Chạy độc lập
  • có không gian bộ nhớ riêng của họ.

Hãy xem xét chương trình dưới đây để hiểu khái niệm này:

  result = multiprocessing.Array['i', 4]
1 
  result = multiprocessing.Array['i', 4]
2

  result = multiprocessing.Array['i', 4]
3
  result = multiprocessing.Array['i', 4]
4 
  result = multiprocessing.Array['i', 4]
5

  result = multiprocessing.Array['i', 4]
6 
  result = multiprocessing.Array['i', 4]
7

  result = multiprocessing.Array['i', 4]
8
  result = multiprocessing.Array['i', 4]
9 
  square_sum = multiprocessing.Value['i']
0

  result = multiprocessing.Array['i', 4]
8
  square_sum = multiprocessing.Value['i']
2 
  square_sum = multiprocessing.Value['i']
3
  square_sum = multiprocessing.Value['i']
4 
  square_sum = multiprocessing.Value['i']
5

  square_sum = multiprocessing.Value['i']
6
  square_sum = multiprocessing.Value['i']
7
  square_sum = multiprocessing.Value['i']
8 
  square_sum = multiprocessing.Value['i']
9

  result = multiprocessing.Array['i', 4]
8
  square_sum = multiprocessing.Value['i', 10]
1
  square_sum = multiprocessing.Value['i', 10]
2
  square_sum = multiprocessing.Value['i', 10]
3
  square_sum = multiprocessing.Value['i', 10]
4
  square_sum = multiprocessing.Value['i', 10]
5
  square_sum = multiprocessing.Value['i', 10]
6

  square_sum = multiprocessing.Value['i', 10]
7 
  square_sum = multiprocessing.Value['i', 10]
8
  result = multiprocessing.Array['i', 4]
4
  result = multiprocessing.Array['i', 4]
4 
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
1
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
2

  result = multiprocessing.Array['i', 4]
8
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
4
  result = multiprocessing.Array['i', 4]
4 
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
6
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
7
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
8
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
9
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
8
  for idx, num in enumerate[mylist]:
      result[idx] = num * num
1
  p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
8
  for idx, num in enumerate[mylist]:
      result[idx] = num * num
3
  for idx, num in enumerate[mylist]:
      result[idx] = num * num
4

  result = multiprocessing.Array['i', 4]
8
  for idx, num in enumerate[mylist]:
      result[idx] = num * num
6
  result = multiprocessing.Array['i', 4]
4 
  for idx, num in enumerate[mylist]:
      result[idx] = num * num
8
  result = multiprocessing.Array['i', 4]
4
  square_sum.value = sum[result]
0
  result = multiprocessing.Array['i', 4]
4
  square_sum.value = sum[result]
2

  result = multiprocessing.Array['i', 4]
8
  square_sum.value = sum[result]
4

  result = multiprocessing.Array['i', 4]
8
  square_sum.value = sum[result]
6

  result = multiprocessing.Array['i', 4]
8
  square_sum = multiprocessing.Value['i', 10]
1
  square_sum = multiprocessing.Value['i', 10]
2
  print["Result[in process p1]: {}".format[result[:]]]
0
  square_sum = multiprocessing.Value['i', 10]
4
  square_sum = multiprocessing.Value['i', 10]
5
  square_sum = multiprocessing.Value['i', 10]
6

Result[in process p1]: [1, 4, 9, 16]
Result[in main program]: []

Trong ví dụ trên, chúng tôi cố gắng in nội dung kết quả danh sách toàn cầu tại hai địa điểm:result at two places:

  • Trong hàm square_list. Vì, chức năng này được gọi theo quy trình P1, danh sách kết quả chỉ được thay đổi trong không gian bộ nhớ của P1.square_list function. Since, this function is called by process p1, result list is changed in memory space of process p1 only.
  • Sau khi hoàn thành quá trình P1 trong chương trình chính. Vì chương trình chính được chạy theo một quy trình khác, không gian bộ nhớ của nó vẫn chứa danh sách kết quả trống.p1 in main program. Since main program is run by a different process, its memory space still contains the empty result list.

Sơ đồ hiển thị bên dưới xóa khái niệm này:

Chia sẻ dữ liệu giữa các quy trình

  1. Bộ nhớ chia sẻ: Mô -đun đa xử lý cung cấp các đối tượng mảng và giá trị để chia sẻ dữ liệu giữa các quy trình.multiprocessing module provides Array and Value objects to share data between processes.
    • Mảng: Một mảng CTYPE được phân bổ từ bộ nhớ chia sẻ. a ctypes array allocated from shared memory.
    • Giá trị: Một đối tượng CTYPES được phân bổ từ bộ nhớ chia sẻ. a ctypes object allocated from shared memory.

    Đưa ra dưới đây là một ví dụ đơn giản hiển thị việc sử dụng mảng và giá trị để chia sẻ dữ liệu giữa các quy trình.Array and Value for sharing data between processes.

      result = multiprocessing.Array['i', 4]
    1 
      result = multiprocessing.Array['i', 4]
    2

      result = multiprocessing.Array['i', 4]
    3
      result = multiprocessing.Array['i', 4]
    4 
      result = multiprocessing.Array['i', 4]
    5

      result = multiprocessing.Array['i', 4]
    6 
      result = multiprocessing.Array['i', 4]
    7

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    9 
      square_sum = multiprocessing.Value['i']
    0

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i']
    2 
      square_sum = multiprocessing.Value['i']
    3
      square_sum = multiprocessing.Value['i']
    4 
      square_sum = multiprocessing.Value['i']
    5

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
      square_sum = multiprocessing.Value['i', 10]
    3
      square_sum = multiprocessing.Value['i', 10]
    4
      square_sum = multiprocessing.Value['i', 10]
    5
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    11

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    15
      square_sum = multiprocessing.Value['i', 10]
    4
      square_sum = multiprocessing.Value['i', 10]
    5
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    18

      square_sum = multiprocessing.Value['i', 10]
    7 
      square_sum = multiprocessing.Value['i', 10]
    8
      result = multiprocessing.Array['i', 4]
    4
      result = multiprocessing.Array['i', 4]
    4 
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    1
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    2

      result = multiprocessing.Array['i', 4]
    8
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    4
      result = multiprocessing.Array['i', 4]
    4 
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    6
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    7
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    9
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    1
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    3
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    4

      result = multiprocessing.Array['i', 4]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    6
      result = multiprocessing.Array['i', 4]
    4 
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    8
      result = multiprocessing.Array['i', 4]
    4
      square_sum.value = sum[result]
    0
      result = multiprocessing.Array['i', 4]
    4
      square_sum.value = sum[result]
    2

    Trong ví dụ trên, chúng tôi cố gắng in nội dung kết quả danh sách toàn cầu tại hai địa điểm:

    Trong hàm square_list. Vì, chức năng này được gọi theo quy trình P1, danh sách kết quả chỉ được thay đổi trong không gian bộ nhớ của P1.

      result = multiprocessing.Array['i', 4]
    8
      square_sum.value = sum[result]
    4

      result = multiprocessing.Array['i', 4]
    8
      square_sum.value = sum[result]
    6

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
      print["Result[in process p1]: {}".format[result[:]]]
    0
      square_sum = multiprocessing.Value['i', 10]
    4
      square_sum = multiprocessing.Value['i', 10]
    5
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    11

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    73
      square_sum = multiprocessing.Value['i', 10]
    4
      square_sum = multiprocessing.Value['i', 10]
    5
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    18

    Sau khi hoàn thành quá trình P1 trong chương trình chính. Vì chương trình chính được chạy theo một quy trình khác, không gian bộ nhớ của nó vẫn chứa danh sách kết quả trống.

    Sơ đồ hiển thị bên dưới xóa khái niệm này:

    • Chia sẻ dữ liệu giữa các quy trìnhresult like this:
        result = multiprocessing.Array['i', 4]
      • Bộ nhớ chia sẻ: Mô -đun đa xử lý cung cấp các đối tượng mảng và giá trị để chia sẻ dữ liệu giữa các quy trình.data type. ‘i’ stands for integer whereas ‘d’ stands for float data type.
      • Mảng: Một mảng CTYPE được phân bổ từ bộ nhớ chia sẻ.size of array. Here, we create an array of 4 elements.

      Giá trị: Một đối tượng CTYPES được phân bổ từ bộ nhớ chia sẻ.square_sum like this:

        square_sum = multiprocessing.Value['i']

      Đưa ra dưới đây là một ví dụ đơn giản hiển thị việc sử dụng mảng và giá trị để chia sẻ dữ liệu giữa các quy trình.

        square_sum = multiprocessing.Value['i', 10]

    •   result = multiprocessing.Array['i', 4]
      6 
        print["Result[in process p1]: {}".format[result[:]]]
      7result and square_sum as arguments while creating Process object.
        p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]

    •   result = multiprocessing.Array['i', 4]
      8
        square_sum = multiprocessing.Value['i']
      2 
        print["Sum of squares[in process p1]: {}".format[square_sum.value]]
      0
        square_sum = multiprocessing.Value['i']
      4 
        print["Sum of squares[in process p1]: {}".format[square_sum.value]]
      2
        print["Sum of squares[in process p1]: {}".format[square_sum.value]]
      3       array elements are given a value by specifying index of array element.
        for idx, num in enumerate[mylist]:
      result[idx] = num * num


        square_sum = multiprocessing.Value['i']
      6
        print["Sum of squares[in process p1]: {}".format[square_sum.value]]
      5
        result = multiprocessing.Array['i', 4]
      4 
        square_sum = multiprocessing.Value['i']
      3
        square_sum = multiprocessing.Value['i']
      8 
        print["Sum of squares[in process p1]: {}".format[square_sum.value]]
      9       is given a value by using its value attribute:

        square_sum.value = sum[result]

    •   result = multiprocessing.Array['i', 4]
      8
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      01
        result = multiprocessing.Array['i', 4]
      4 
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      03
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      04result array elements, we use result[:] to print complete array.
        print["Result[in process p1]: {}".format[result[:]]]


        result = multiprocessing.Array['i', 4]
      8
        result = multiprocessing.Array['i', 4]
      3
        result = multiprocessing.Array['i', 4]
      4 
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      40
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      41
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      42
        for idx, num in enumerate[mylist]:
      result[idx] = num * num
      3
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      44square_sum is simply printed as:

        print["Sum of squares[in process p1]: {}".format[square_sum.value]]


      result = multiprocessing.Array['i', 4]
    8
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    46
      result = multiprocessing.Array['i', 4]
    4 
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    48
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    41
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    44Array and Value object:

  2.   result = multiprocessing.Array['i', 4]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    6
      result = multiprocessing.Array['i', 4]
    4 
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    8
      result = multiprocessing.Array['i', 4]
    4
      square_sum.value = sum[result]
    0
      result = multiprocessing.Array['i', 4]
    4
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    58    Whenever a python program starts, a server process is also started. From there on, whenever a new process is needed, the parent process connects to the server and requests it to fork a new process.
    A server process can hold Python objects and allows other processes to manipulate them using proxies.
    multiprocessing module provides a Manager class which controls a server process. Hence, managers provide a way to create data that can be shared between different processes.

    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    shared memory objects because they can be made to support arbitrary object types like lists, dictionaries, Queue, Value, Array, etc. Also, a single manager can be shared by processes on different computers over a network. They are, however, slower than using shared memory.

    Hãy để chúng tôi cố gắng hiểu từng dòng mã trên:

      result = multiprocessing.Array['i', 4]
    1 
      result = multiprocessing.Array['i', 4]
    2

    Trước hết, chúng tôi tạo ra một kết quả mảng như thế này: ________ 2

    Đối số đầu tiên là kiểu dữ liệu. Tôi là viết tắt của số nguyên trong khi ‘D, viết tắt của kiểu dữ liệu float.

      square_sum = multiprocessing.Value['i']
    6
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    89
      square_sum = multiprocessing.Value['i', 10]
    4
      square_sum = multiprocessing.Value['i', 10]
    5
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    92
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    93
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    94
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    7
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    96

      result = multiprocessing.Array['i', 4]
    6 
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    98

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    00

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
      result = multiprocessing.Array['i', 4]
    04
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    44

      square_sum = multiprocessing.Value['i', 10]
    7 
      square_sum = multiprocessing.Value['i', 10]
    8
      result = multiprocessing.Array['i', 4]
    4
      result = multiprocessing.Array['i', 4]
    4 
      result = multiprocessing.Array['i', 4]
    10
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    2

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    13

      square_sum = multiprocessing.Value['i']
    6
      result = multiprocessing.Array['i', 4]
    15
      result = multiprocessing.Array['i', 4]
    4 
      result = multiprocessing.Array['i', 4]
    17
      result = multiprocessing.Array['i', 4]
    18__

      square_sum = multiprocessing.Value['i']
    6
      result = multiprocessing.Array['i', 4]
    33
      result = multiprocessing.Array['i', 4]
    4 
      square_sum = multiprocessing.Value['i', 10]
    2
      result = multiprocessing.Array['i', 4]
    36
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    42
      result = multiprocessing.Array['i', 4]
    38
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    44

      square_sum = multiprocessing.Value['i']
    6
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    6
      result = multiprocessing.Array['i', 4]
    4 
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    8
      result = multiprocessing.Array['i', 4]
    4
      result = multiprocessing.Array['i', 4]
    45
      result = multiprocessing.Array['i', 4]
    4
      result = multiprocessing.Array['i', 4]
    47

      square_sum = multiprocessing.Value['i']
    6
      result = multiprocessing.Array['i', 4]
    49
      result = multiprocessing.Array['i', 4]
    4 
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    8
      result = multiprocessing.Array['i', 4]
    4
      result = multiprocessing.Array['i', 4]
    53
      result = multiprocessing.Array['i', 4]
    4
      result = multiprocessing.Array['i', 4]
    55

      square_sum = multiprocessing.Value['i']
    6
      square_sum.value = sum[result]
    4

      square_sum = multiprocessing.Value['i']
    6
      square_sum.value = sum[result]
    6

      square_sum = multiprocessing.Value['i']
    6
      result = multiprocessing.Array['i', 4]
    61

      square_sum = multiprocessing.Value['i']
    6
      result = multiprocessing.Array['i', 4]
    63

    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    0

    Hãy để chúng tôi cố gắng hiểu phần trên của mã:

    • Trước hết, chúng tôi tạo một đối tượng Trình quản lý bằng cách sử dụng: ________ 11manager object using:
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      1

      Tất cả các dòng bên dưới với khối câu lệnh nằm trong phạm vi của đối tượng Trình quản lý.with statement block are under the scope of manager object.

    • Sau đó, chúng tôi tạo một bản ghi danh sách trong bộ nhớ quy trình máy chủ bằng cách sử dụng: ________ 12records in server process memory using:
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      2

      Tương tự, bạn có thể tạo một từ điển làm phương thức Manager.dict.manager.dict method.

    • Cuối cùng, chúng tôi tạo để xử lý P1 [để chèn một bản ghi mới vào danh sách hồ sơ] và P2 [để in bản ghi] và chạy chúng trong khi truyền các bản ghi dưới dạng một trong những đối số.p1 [to insert a new record in records list] and p2 [to print records] and run them while passing records as one of the arguments.

    Khái niệm về quy trình máy chủ được mô tả trong sơ đồ được hiển thị bên dưới:server process is depicted in the diagram shown below:

Giao tiếp giữa các quá trình

Sử dụng hiệu quả nhiều quy trình thường yêu cầu một số giao tiếp giữa chúng, để công việc có thể được chia và kết quả có thể được tổng hợp. Việc xử lý hỗ trợ hai loại kênh giao tiếp giữa các quy trình:
multiprocessing supports two types of communication channel between processes:

  • Xếp hàng
  • Đường ống
  1. Hàng đợi: Một cách đơn giản để giao tiếp giữa quy trình với đa xử lý là sử dụng hàng đợi để truyền tin nhắn qua lại. Bất kỳ đối tượng Python nào cũng có thể đi qua hàng đợi.A simple way to communicate between process with multiprocessing is to use a Queue to pass messages back and forth. Any Python object can pass through a Queue.
    Note: The multiprocessing.Queue class is a near clone of queue.Queue.
    Consider the example program given below:

      result = multiprocessing.Array['i', 4]
    1 
      result = multiprocessing.Array['i', 4]
    2

      result = multiprocessing.Array['i', 4]
    6 
      result = multiprocessing.Array['i', 4]
    67

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i']
    2 
      square_sum = multiprocessing.Value['i']
    3
      square_sum = multiprocessing.Value['i']
    4 
      square_sum = multiprocessing.Value['i']
    5

      square_sum = multiprocessing.Value['i']
    6
      result = multiprocessing.Array['i', 4]
    74
      square_sum = multiprocessing.Value['i']
    8 
      square_sum = multiprocessing.Value['i']
    9

      result = multiprocessing.Array['i', 4]
    6 
      result = multiprocessing.Array['i', 4]
    78

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
      result = multiprocessing.Array['i', 4]
    82
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    44

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    85 
      result = multiprocessing.Array['i', 4]
    86 
      result = multiprocessing.Array['i', 4]
    87

      square_sum = multiprocessing.Value['i']
    6
      square_sum = multiprocessing.Value['i', 10]
    1
      result = multiprocessing.Array['i', 4]
    90

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
      result = multiprocessing.Array['i', 4]
    94
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    44

      square_sum = multiprocessing.Value['i', 10]
    7 
      square_sum = multiprocessing.Value['i', 10]
    8
      result = multiprocessing.Array['i', 4]
    4
      result = multiprocessing.Array['i', 4]
    4 
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    1
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    2

      result = multiprocessing.Array['i', 4]
    8
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    4
      result = multiprocessing.Array['i', 4]
    4 
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    6
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    7
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    9
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    1
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    3
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    4

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i']
    15
      result = multiprocessing.Array['i', 4]
    4 
      square_sum = multiprocessing.Value['i']
    17

      result = multiprocessing.Array['i', 4]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    6
      result = multiprocessing.Array['i', 4]
    4 
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    8
      result = multiprocessing.Array['i', 4]
    4
      square_sum.value = sum[result]
    0
      result = multiprocessing.Array['i', 4]
    4
      square_sum = multiprocessing.Value['i']
    25

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    49
      result = multiprocessing.Array['i', 4]
    4 
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    8
      result = multiprocessing.Array['i', 4]
    4
      square_sum = multiprocessing.Value['i']
    31
      result = multiprocessing.Array['i', 4]
    4
      square_sum = multiprocessing.Value['i']
    33

      result = multiprocessing.Array['i', 4]
    8
      square_sum.value = sum[result]
    4

      result = multiprocessing.Array['i', 4]
    8
      square_sum.value = sum[result]
    6

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    61

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    63

    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    3

    Hãy để chúng tôi cố gắng hiểu từng bước trên từng bước:

    • Thứ nhất, chúng tôi tạo một hàng đợi đa xử lý bằng cách sử dụng: ________ 14multiprocessing Queue using:
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      4
    • Sau đó, chúng tôi vượt qua Hàng đợi trống Q cho chức năng Square_list thông qua quá trình P1. Các yếu tố được chèn vào hàng đợi bằng phương pháp PUT .________ 15q to square_list function through process p1. Elements are inserted to queue using put method.
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      5
    • Để in các phần tử hàng đợi, chúng tôi sử dụng phương thức Get cho đến khi hàng đợi không trống .________ 16get method until queue is not empty.
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      6

    Đưa ra dưới đây là một sơ đồ đơn giản mô tả các hoạt động trên hàng đợi:

  2. Ống: Một đường ống chỉ có thể có hai điểm cuối. Do đó, nó được ưa thích hơn hàng đợi khi chỉ cần giao tiếp hai chiều.A pipe can have only two endpoints. Hence, it is preferred over queue when only two-way communication is required.

    Mô -đun đa xử lý cung cấp chức năng PIPE [] trả về một cặp đối tượng kết nối được kết nối bởi một đường ống. Hai đối tượng kết nối được trả về bởi ống [] đại diện cho hai đầu của đường ống. Mỗi đối tượng kết nối có các phương thức gửi [] và recv [] [trong số các phương thức khác] .consider chương trình được đưa ra dưới đây: module provides Pipe[] function which returns a pair of connection objects connected by a pipe. The two connection objects returned by Pipe[] represent the two ends of the pipe. Each connection object has send[] and recv[] methods [among others].
    Consider the program given below:

      result = multiprocessing.Array['i', 4]
    1 
      result = multiprocessing.Array['i', 4]
    2

      result = multiprocessing.Array['i', 4]
    6 
      result = multiprocessing.Array['i', 4]
    67

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i']
    2 
      square_sum = multiprocessing.Value['i']
    3
      square_sum = multiprocessing.Value['i']
    4 
      square_sum = multiprocessing.Value['i']
    5

      square_sum = multiprocessing.Value['i']
    6
      square_sum = multiprocessing.Value['i']
    52

      square_sum = multiprocessing.Value['i']
    6
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
      square_sum = multiprocessing.Value['i']
    56
      square_sum = multiprocessing.Value['i', 10]
    4
      square_sum = multiprocessing.Value['i', 10]
    5
      square_sum = multiprocessing.Value['i']
    59

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i']
    61

      square_sum = multiprocessing.Value['i']
    6
      result = multiprocessing.Array['i', 4]
    74
      square_sum = multiprocessing.Value['i']
    8 
      square_sum = multiprocessing.Value['i']
    9

      result = multiprocessing.Array['i', 4]
    6 
      result = multiprocessing.Array['i', 4]
    78

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    85 
      result = multiprocessing.Array['i', 4]
    86 
      result = multiprocessing.Array['i', 4]
    87

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
      result = multiprocessing.Array['i', 4]
    94
    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    44

      square_sum = multiprocessing.Value['i']
    79
      square_sum = multiprocessing.Value['i']
    80

      square_sum = multiprocessing.Value['i']
    6
      square_sum = multiprocessing.Value['i', 10]
    1
      square_sum = multiprocessing.Value['i', 10]
    2
      square_sum = multiprocessing.Value['i']
    84
      square_sum = multiprocessing.Value['i', 10]
    4
      square_sum = multiprocessing.Value['i', 10]
    5
      square_sum = multiprocessing.Value['i']
    59

      square_sum = multiprocessing.Value['i', 10]
    7 
      square_sum = multiprocessing.Value['i', 10]
    8
      result = multiprocessing.Array['i', 4]
    4
      result = multiprocessing.Array['i', 4]
    4 
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    1
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    2

      result = multiprocessing.Array['i', 4]
    8
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    4
      result = multiprocessing.Array['i', 4]
    4 
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    6
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    7
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    9
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    1
      p1 = multiprocessing.Process[target=square_list, args=[mylist, result, square_sum]]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    3
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    4

      result = multiprocessing.Array['i', 4]
    8
      square_sum = multiprocessing.Value['i']
    15
      result = multiprocessing.Array['i', 4]
    4 
      square_sum = multiprocessing.Value['i']
    17

      result = multiprocessing.Array['i', 4]
    8
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    6
      result = multiprocessing.Array['i', 4]
    4 
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    8
      result = multiprocessing.Array['i', 4]
    4
      square_sum.value = sum[result]
    0
      result = multiprocessing.Array['i', 4]
    4
      square_sum = multiprocessing.Value['i']
    25

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    49
      result = multiprocessing.Array['i', 4]
    4 
      for idx, num in enumerate[mylist]:
      result[idx] = num * num
    8
      result = multiprocessing.Array['i', 4]
    4
      square_sum = multiprocessing.Value['i']
    31
      result = multiprocessing.Array['i', 4]
    4
      square_sum = multiprocessing.Value['i']
    33

      result = multiprocessing.Array['i', 4]
    8
      square_sum.value = sum[result]
    4

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    61

      result = multiprocessing.Array['i', 4]
    8
      square_sum.value = sum[result]
    6

      result = multiprocessing.Array['i', 4]
    8
      result = multiprocessing.Array['i', 4]
    63

    Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
    7

    Hãy để chúng tôi cố gắng hiểu mã ở trên:

    • Một đường ống được tạo ra đơn giản bằng cách sử dụng: ________ 18

      Hàm trả về hai đối tượng kết nối cho hai đầu của đường ống.

    • Tin nhắn được gửi từ đầu này sang đầu khác bằng phương pháp gửi .________ 19send method.
      Result[in process p1]: [1, 4, 9, 16]
Sum of squares[in process p1]: 30
Result[in main program]: [1, 4, 9, 16]
Sum of squares[in main program]: 30
      9
    • Để nhận bất kỳ tin nhắn nào ở một đầu của đường ống, chúng tôi sử dụng phương thức RECV .________ 20recv method.
        result = multiprocessing.Array['i', 4]
      0
    • Trong chương trình trên, chúng tôi gửi một danh sách các tin nhắn từ đầu này sang đầu khác. Ở đầu bên kia, chúng tôi đọc tin nhắn cho đến khi chúng tôi nhận được tin nhắn cuối cùng.

    Hãy xem xét sơ đồ được đưa ra dưới đây cho thấy đường ống B/W quan hệ và các quy trình:

Lưu ý: Dữ liệu trong đường ống có thể bị hỏng nếu hai quá trình [hoặc luồng] cố gắng đọc từ hoặc ghi vào cùng một đầu của đường ống cùng một lúc. Tất nhiên, không có nguy cơ tham nhũng từ các quá trình sử dụng các đầu khác nhau của đường ống cùng một lúc. Cũng lưu ý rằng hàng đợi thực hiện đồng bộ hóa thích hợp giữa các quá trình, với chi phí phức tạp hơn. Do đó, hàng đợi được cho là chủ đề và xử lý an toàn! Data in a pipe may become corrupted if two processes [or threads] try to read from or write to the same end of the pipe at the same time. Of course, there is no risk of corruption from processes using different ends of the pipe at the same time. Also note that Queues do proper synchronization between processes, at the expense of more complexity. Hence, queues are said to be thread and process safe!

Next:

  • Đồng bộ hóa và gộp các quy trình trong Python

Bài viết này được đóng góp bởi Nikhil Kumar. Nếu bạn thích GeekSforGeeks và muốn đóng góp, bạn cũng có thể viết một bài viết bằng Write.GeekSforGeek.org hoặc gửi bài viết của bạn. Xem bài viết của bạn xuất hiện trên trang chính của GeekSforGeek và giúp các chuyên viên máy tính khác.Nikhil Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to . See your article appearing on the GeeksforGeeks main page and help other Geeks.

Vui lòng viết nhận xét nếu bạn tìm thấy bất cứ điều gì không chính xác, hoặc bạn muốn chia sẻ thêm thông tin về chủ đề được thảo luận ở trên.


Làm thế nào để bạn truyền đạt hai quá trình trong Python?

Mỗi đối tượng có hai phương thức - gửi [] và recv [], để giao tiếp giữa các quy trình.send[] and recv[], to communicate between processes.

Làm thế nào để bạn giao tiếp giữa quá trình cha mẹ và con cái trong Python?

Dưới đây là một chương trình Python đơn giản để chứng minh giao tiếp giữa quy trình cha và quy trình con bằng phương pháp ống. PIPE [] Cuộc gọi hệ thống: Phương thức PIPE [] tạo một đường ống và trả về một cặp mô tả tệp [R, W] có thể sử dụng để đọc và ghi, tương ứng.using the pipe method. pipe[] System call : The method pipe[] creates a pipe and returns a pair of file descriptors [r, w] usable for reading and writing, respectively.

Làm thế nào để các quy trình hoạt động trong Python?

Trong Python, một quá trình là một ví dụ của trình thông dịch Python thực thi mã Python.Trong Python, quá trình đầu tiên được tạo ra khi chúng tôi chạy chương trình của chúng tôi được gọi là 'quy trình chính'.Nó cũng là một quá trình cha mẹ và có thể được gọi là quy trình chính của cha mẹ.Quá trình chính sẽ tạo ra quy trình hoặc quy trình con đầu tiên.a process is an instance of the Python interpreter that executes Python code. In Python, the first process created when we run our program is called the 'MainProcess'. It is also a parent process and may be called the main parent process. The main process will create the first child process or processes.

Làm thế nào để xếp hàng đa xử lý Python hoạt động?

Hàng đợi là một cấu trúc dữ liệu mà các mục có thể được thêm vào bằng một cuộc gọi để đặt [] và từ đó các mục có thể được truy xuất bằng cách gọi để nhận [].Đa xử lý.Hàng đợi cung cấp hàng đợi FIFO đầu tiên, đầu tiên, có nghĩa là các mục được lấy từ hàng đợi theo thứ tự chúng được thêm vào.. The multiprocessing. Queue provides a first-in, first-out FIFO queue, which means that the items are retrieved from the queue in the order they were added.

Bài Viết Liên Quan

Hướng dẫn which one is responsible of running javascript code mcq? - cái nào chịu trách nhiệm chạy mã javascript mcq?
Hướng dẫn how do you write a fibonacci series in python? - làm thế nào để bạn viết một chuỗi fibonacci trong python?
Hướng dẫn hex decode python - giải mã hex mã trăn
Đặc trưng hệ điều hành linux
Hướng dẫn how do you check if a variable is in a dictionary python? - làm cách nào để kiểm tra xem một biến có nằm trong python từ điển không?
Hướng dẫn normalize negative and positive values python - chuẩn hóa các giá trị âm và dương trong python
Hướng dẫn how do you call a javascript code? - làm thế nào để bạn gọi một mã javascript?
Hướng dẫn css class name convention - quy ước tên lớp css
Hướng dẫn how to remove multiple blank rows in excel - cách xóa nhiều hàng trống trong excel
2023 Ford F250
Phim hay nhất năm nay 2023
Hướng dẫn python split string in half - python chia chuỗi thành một nửa
Hướng dẫn how do i convert text to date in spreadsheet? - làm cách nào để chuyển đổi văn bản thành ngày tháng trong bảng tính?
Hướng dẫn python run batch file - python chạy tệp hàng loạt
Hướng dẫn read array in one line c++ - đọc mảng trong một dòng c ++
Hướng dẫn javascript objects in depth - các đối tượng javascript chuyên sâu
Lịch nghỉ tết chứng khoán 2023
Hướng dẫn how do i find python path in windows? - làm cách nào để tìm đường dẫn python trong windows?
Hướng dẫn delete filter view google sheets - xóa chế độ xem bộ lọc google trang tính
Hướng dẫn what does body_class () function actually do in wordpress? - hàm body_class () thực sự làm gì trong wordpress?

Toplist mới

#1
Top 4 uống nước chanh sả mật ong có tác dụng gì 2023
6 tháng trước
#2
Top 10 bài tập làm văn số 5 lớp 7 de 4 2023
6 tháng trước
#3
Top 3 vừa chơi đã có tài khoản vương giả chap 1 2023
6 tháng trước
#4
Top 6 anh sẽ on thôi cover phạm nguyên ngọc lyrics 2023
6 tháng trước
#5
Top 7 tài liệu quản lý nhà nước và quản lý ngành giáo dục đào tạo 2023
6 tháng trước
#6
Top 7 hãy ra khỏi người đó đi hợp âm 2023
6 tháng trước
#7
Top 6 giáo án thơ về thăm nhà bác 2023
6 tháng trước
#8
Top 8 giáo án ngữ văn 6 cánh diều 2023
6 tháng trước
#9
Top 9 tinh bột tham gia phản ứng nào 2023
6 tháng trước

Bài mới nhất

Chi phí xăng dầu cho vào tài khoản nào năm 2024
Bảng hệ thống tài khoản kế toán mới nhất 2023 năm 2024
Mũi va mengoc bc2 là mũi gì năm 2024
Cung bọ cạp còn gọi là cung gì năm 2024
14 tháng 1 năm 2023 là ngày gì năm 2024
Xài những sản phẩm gì của sum là tốt nhất năm 2024
Http www.animesex.pro en search highschool 20dxd-top 1.html năm 2024
Bị hạt gạo ở móng tay là bị gì năm 2024
Hiền tài sinh lỗi số trong tam quốc diễn nghĩa năm 2024
Chứng nhận bổ túc văn hóa tiếng anh là gì năm 2024

Chủ Đề

programming Hỏi Đáp Mẹo Hay Toplist Là gì Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Top List bao nhieu bao nhiêu hướng dẫn So Sánh Tiếng anh Bài tập So sánh Xây Đựng Sản phẩm tốt Ngôn ngữ Bài Tập Máy tính javascript Ở đâu Hướng dẫn Thế nào Dịch Tại sao Đại học Món Ngon Facebook Khoa Học