PyQt5.QtCore模块中的进程间通信机制

PyQt5是一个使用Python语言编写的Qt图形界面框架，它包含了Qt中的各种模块，其中QtCore模块提供了一些与平台无关的功能，包括进程间通信（IPC）机制。

在PyQt5.QtCore模块中，有两种主要的进程间通信机制：信号与槽机制和共享内存。

1. 信号与槽机制：

信号与槽机制是PyQt5中实现进程间通信的一种方式。它通过信号（signal）和槽（slot）的方式来实现，当一个对象发出信号时，与之关联的槽函数会被调用。

下面是一个使用信号与槽机制实现进程间通信的例子：

   from PyQt5.QtWidgets import QApplication, QLabel
   from PyQt5.QtCore import QObject, pyqtSignal, pyqtSlot, QThread
   
   
   class Worker(QThread):
       finished = pyqtSignal()
   
       def run(self):
           for i in range(5):
               print("Working...")
               self.sleep(1)
           self.finished.emit()
   
   
   class MainWindow(QLabel):
       def __init__(self):
           super().__init__()
           self.resize(300, 200)
   
       @pyqtSlot()
       def handleFinished(self):
           self.setText("Work finished.")
   
   
   if __name__ == '__main__':
       app = QApplication([])
       mainWindow = MainWindow()
   
       worker = Worker()
       worker.finished.connect(mainWindow.handleFinished)
   
       mainWindow.show()
       worker.start()
   
       app.exec()
   

在这个例子中，Worker类继承自QThread，它是一个后台工作线程，每秒会打印一次"Working..."，一共执行5次。当工作完成后，会发出"finished"信号。MainWindow类继承自QLabel，它是一个GUI窗口，当接收到"finished"信号时，会调用handleFinished()槽函数来更新界面。

在主程序中，首先创建了一个QApplication实例，然后创建了一个MainWindow实例，并将handleFinished()槽函数与worker对象的finished信号连接起来。最后，调用worker的start()方法来启动工作线程，调用app的exec()方法来进入事件循环。

运行这个例子，会在窗口中显示"Working..."，当工作完成后，窗口会显示"Work finished."。

2. 共享内存：

共享内存是另一种PyQt5中实现进程间通信的方式。它允许多个进程在同一块内存区域中共享数据，从而实现数据的交换。

下面是一个使用共享内存实现进程间通信的例子：

   from PyQt5.QtCore import QSharedMemory, QBuffer, QIODevice
   from PyQt5.QtGui import QImage
   import numpy as np
   
   
   def write_image_to_shared_memory(image: np.ndarray, shared_memory_key: str):
       shared_memory = QSharedMemory()
       if shared_memory.attach():
           shared_memory.detach()
   
       buffer = QBuffer()
       buffer.open(QIODevice.ReadWrite)
       image.save(buffer, "PNG")
   
       shared_memory.create(len(buffer.data())+1)
       shared_memory.lock()
   
       shared_memory_data = bytearray(shared_memory.data())
       buffer_data = buffer.data().data()
       shared_memory_data[:len(buffer_data)] = buffer_data
   
       shared_memory.unlock()
       shared_memory.detach()
   
   
   def read_image_from_shared_memory(shared_memory_key: str) -> np.ndarray:
       shared_memory = QSharedMemory()
       if not shared_memory.attach():
           return None
   
       shared_memory.lock()
       shared_memory_data = np.frombuffer(shared_memory.data(), dtype=np.uint8)
       image = QImage.fromData(shared_memory_data)
       shared_memory.unlock()
       shared_memory.detach()
   
       return np.array(image)
   
   
   if __name__ == '__main__':
       image = np.ones((256, 256, 3), dtype=np.uint8) * 255
       write_image_to_shared_memory(image, "shared_memory_key")
       read_image = read_image_from_shared_memory("shared_memory_key")
   
       print(np.array_equal(image, read_image))  # True
   

在这个例子中，首先定义了一个write_image_to_shared_memory()函数用于将图片写入共享内存，以及一个read_image_from_shared_memory()函数用于从共享内存中读取图片。两个函数中的shared_memory_key参数被用作共享内存的标识符。

在主程序中，首先创建了一个256x256的全白图片，然后调用write_image_to_shared_memory()函数将图片写入共享内存。接着，调用read_image_from_shared_memory()函数从共享内存中读取图片。最后，使用np.array_equal()函数比较原始图片和从共享内存中读取的图片，如果两者相等则输出True。

运行这个例子，会输出True，表示共享内存机制成功实现了进程间的图片数据传输。

总结：

通过PyQt5的QtCore模块，我们可以使用信号与槽机制和共享内存来实现进程间通信。信号与槽机制可以在不同的对象之间传递数据或信号，实现进程间的信息交流；而共享内存则允许多个进程在同一块内存区域中共享数据，实现进程间数据的交换。这些机制能够帮助我们实现更加灵活和高效的进程间通信。