标签: multiprocessing

在我的 GUI 代码中，我尝试通过单击一个按钮来同时运行循环 1 和循环 2。因此，我曾经Thread实现过这一点。但我也尝试通过单击另一个按钮来阻止它，但失败了。在stackoverflow上搜索后，我发现没有直接杀死 的方法Thread。这是代码的一部分：

def loop1():
    while True:
        call (["raspivid -n -op 150 -w 640 -h 480 -b 2666666.67 -t 5000 -o test.mp4"],shell=True)
        call (["raspivid -n -op 150 -w 640 -h 480 -b 2666666.67 -t 5000 -o test1.mp4"],shell=True)

def loop2():
    while True:
        call (["arecord -D plughw:1 --duration=5 -f cd -vv rectest.wav"],shell=True)
        call (["arecord -D plughw:1 --duration=5 -f cd -vv rectest1.wav"],shell=True)

def combine():
    Thread(target = loop1).start()
    Thread(target = loop2).start()

def stop():
    Thread(target = loop1).terminate() …

• 在提出这个问题之前，我已经搜索了很多关于“跨线程共享相同的数据库连接”的信息。我得到的大多数答案是否定的，并使用连接池代替，但很少有人详细解释为什么我们不能这样做。

• 然后我使用多处理和多线程编写了一个示例代码，我试图弄清楚它，但仍然有一些困难需要解决。这是我得到的：

  多重处理：

  import multiprocessing as multiprocessing
  import pymysql
  conn = pymysql.connect(host='localhost', port=3306, user='root', passwd='123456', db='test')
  
  def operate(sql):
      cur = conn.cursor()
      cur.execute(sql)
      cur.close()
      return cur.fetchall()
  
  pool = multiprocessing.Pool(4)
  res = []
  
  for seq in range(1, 3):
      sql = "SELECT * FROM `user` WHERE `id` = %d" % seq
      p = pool.apply_async(operate, [sql, ])
      res.append(p)
  
  
  pool.close()
  pool.join()
  
  conn.close()
  for j in res:
      print(j.get())
  

  Run Code Online (Sandbox Code Playgroud)

  正如预期的那样，这段代码无法正常工作：

  ((None, None, 1, 'ttt', 'hhh', 1, 0, ''),)   # process1
  ((None, None, 2, 'zzz', '1256', 1, 0, …

  Run Code Online (Sandbox Code Playgroud)

我一整天都被这个问题困扰，并且无法找到与我想要完成的任务相关的任何解决方案。

我试图将队列传递给子进程中生成的线程。队列在入口文件中创建并作为参数传递给每个子流程。

我正在制作一个模块化程序来a）运行神经网络b）在需要时自动更新网络模型c）将事件/图像从神经网络记录到服务器。我以前的程序只崇拜一个运行多个线程的 CPU 核心，并且速度变得相当慢，因此我决定需要对程序的某些部分进行子处理，以便它们可以在自己的内存空间中运行，以充分发挥其潜力。

子流程：

1. 客户端-服务器通信
2. 网络摄像头控制和图像处理
3. 神经网络的推理（有 2 个神经网络，每个神经网络都有自己的进程）

总共 4 个子流程。

在开发过程中，我需要在每个进程之间进行通信，以便它们都位于同一页面上，并包含来自服务器的事件等。所以据我所知，队列将是最好的选择。

（澄清：来自“多处理”模块的“队列”，而不是“队列”模块）

~~不过~~

每个子进程都会产生自己的线程。例如，第一个子进程将产生多个线程：每个队列一个线程，用于侦听来自不同服务器的事件并将它们传递到程序的不同区域；一个线程监听从神经网络之一接收图像的队列；一个线程监听从网络摄像头接收实时图像的队列；一个线程监听从另一个神经网络接收输出的队列。

我可以毫无问题地将队列传递给子流程，并且可以有效地使用它们。但是，当我尝试将它们传递给每个子进程中的线程时，我收到上述错误。

我对多重处理相当陌生；然而，除了共享内存空间和 GIL 之外，其背后的方法看起来与线程相对相同。

这是来自 Main.py；程序入口。

from lib.client import Client, Image

from multiprocessing import Queue, Process

class Main():

    def __init__(self, server):

        self.KILLQ = Queue()
        self.CAMERAQ = Queue()

        self.CLIENT = Client((server, 2005), self.KILLQ, self.CAMERAQ)
        self.CLIENT_PROCESS = Process(target=self.CLIENT.do, daemon=True)

        self.CLIENT_PROCESS.start()

if __name__ == '__main__':
    m = Main('127.0.0.1')
    while True:
        m.KILLQ.put("Hello world")

这是来自 client.py （在名为 lib 的文件夹中）

class Client():

    def __init__(self, connection, killq, cameraq):

        self.TCP_IP …

I\xe2\x80\x99m 希望在 Python 中的两个进程之间共享 bool 值。我有一个队列，我想通过让它在第一次运行 while 循环时填满来初始化。此后，布尔值设置为 true，其他进程现在可以开始从队列中读取。

注意：我\xe2\x80\x99已经尝试使用值，但布尔不会\xe2\x80\x99t更新。我是否需要将 bool 作为参数传递给进程才能使其工作？

另外，这是我的代码：

#Main thread\nbool_val = Value(\xe2\x80\x9ci\xe2\x80\x9d, 0)\n\n#queue gets written to...\n\nbool_val = Value(\xe2\x80\x9ci\xe2\x80\x9d, 1)\n\n

#other thread\nIf bool(bool_val) is True:\n    #read from queue\n

因此，当我在与 print 后跟 time.sleep 相同的代码中导入 multiprocessing 时，它将打印字符串 3 次，而不是我请求的 1 次。我想知道为什么会发生这种情况以及如何解决这个问题（如果可能），提前谢谢您。我的代码如下。

import time
import multiprocessing

print('teeeest')
time.sleep(3)

def test1():
    print('test1')
def test2():
    print('test2')

if __name__ == '__main__':
    p1 = multiprocessing.Process(target=test1)
    p2 = multiprocessing.Process(target=test2)
    p1.start()
    p2.start()
    p1.join()
    p2.join()

代码结果如下：

teeeest
teeeest
teeeest
test1
test2

（注意“test1”和“test2”按预期同时发送）

我有一些 C++ 代码，大致包含以下逻辑：

class wrapper_info {
public:
        bool isConnected();
        void connectedHandler();
        void disconnectedHandler();
protected:
        bool _connected;
}

void wrapper_info::connectedHandler() {
        _connected = true;
}

void wrapper_info::disconnectedHandler() {
        _connected = false;
}

bool wrapper_info::isConnected() {
        return _connected;
}

extern "C"
bool is_connected(void *obj) {
        wrapper_info *wrapper_obj = reinterpret_cast<wrapper_info*>(obj);
        return wrapper_obj->isConnected();
}

由于大多数我无法控制的原因，不同的线程（在不同的 CPU 内核上运行）按以下方式调用这些函数。

线程 1、2、3：is_connected(obj)

线程2：connectedHandler()连接发起时。

disconnectedHandler()当连接断开时线程3 。