如何通过multiprocessing将全局SSH对象共享给子进程？

首先明确：SSH连接（如paramiko的SSHClient这类带状态的网络对象）无法通过multiprocessing.Value共享——因为Value仅支持ctype定义的基础数据类型，且这类连接包含套接字、文件描述符等进程绑定资源，跨进程直接共享会导致状态混乱、资源冲突，本身就不是合理的做法。

下面是几种可行的替代方案：

方案1：每个子进程独立建立SSH连接 #

这是最直观且安全的做法，每个子进程自行初始化SSH连接，完全避免共享带来的所有问题。

示例代码：

import multiprocessing

def worker():
    # 子进程内独立创建SSH连接
    ssh = gw_manager.openSSH()
    # 执行具体操作，比如远程命令
    stdin, stdout, stderr = ssh.exec_command("ls -l")
    print(stdout.read().decode())
    # 用完关闭连接
    ssh.close()

if __name__ == "__main__":
    processes = [multiprocessing.Process(target=worker) for _ in range(3)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()

方案2：父进程持有连接，通过队列转发请求 #

如果必须复用单个SSH连接（比如受目标主机连接数限制），可以让父进程维护SSH连接，子进程通过队列发送需要执行的任务，父进程执行后将结果返回给子进程。

示例代码：

import multiprocessing
import threading

def handle_tasks(ssh, task_queue, result_queue):
    # 父进程内的线程，专门处理子进程的任务
    while True:
        task = task_queue.get()
        if task is None:  # 接收终止信号
            break
        cmd = task
        try:
            stdin, stdout, stderr = ssh.exec_command(cmd)
            result = stdout.read().decode()
            result_queue.put((True, result))
        except Exception as e:
            result_queue.put((False, str(e)))

def worker(task_queue, result_queue):
    # 子进程发送任务并接收执行结果
    task_queue.put("df -h")
    success, result = result_queue.get()
    if success:
        print("命令执行结果：", result)
    else:
        print("执行失败：", result)

if __name__ == "__main__":
    # 父进程初始化SSH连接
    ssh = gw_manager.openSSH()
    
    task_queue = multiprocessing.Queue()
    result_queue = multiprocessing.Queue()
    
    # 启动父进程内的任务处理线程
    handler_thread = threading.Thread(target=handle_tasks, args=(ssh, task_queue, result_queue))
    handler_thread.start()
    
    # 启动子进程
    processes = [multiprocessing.Process(target=worker, args=(task_queue, result_queue)) for _ in range(2)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    # 发送终止信号，清理资源
    task_queue.put(None)
    handler_thread.join()
    ssh.close()

方案3：使用multiprocessing.Manager代理对象（谨慎使用） #

部分SSH库的连接对象如果支持序列化（pickle），可以尝试用Manager.Namespace或Manager.Dict共享，但大部分情况下，SSH连接包含的套接字无法被序列化，所以这个方案成功率很低，仅作为备选。

示例代码（仅当gw_manager.openSSH()返回的对象可pickle时可用）：

import multiprocessing

def worker(shared_namespace):
    ssh = shared_namespace.ssh
    # 执行远程操作
    stdin, stdout, stderr = ssh.exec_command("whoami")
    print(stdout.read().decode())

if __name__ == "__main__":
    with multiprocessing.Manager() as manager:
        shared_ns = manager.Namespace()
        shared_ns.ssh = gw_manager.openSSH()
        
        p = multiprocessing.Process(target=worker, args=(shared_ns,))
        p.start()
        p.join()
        shared_ns.ssh.close()

注意：如果运行时出现pickle.PicklingError，说明你的SSH对象无法序列化，此方案不可用。

内容的提问来源于stack exchange，提问作者user12755014