Python中的多处理：同时执行两个函数

我想同时执行以下两个函数

from multiprocessing import Process
import os
import datetime

def func_1(title):
    now = datetime.datetime.now()
    print "hello, world"
    print "Current second: %d" % now.second
    print "Current microsecond: %d" % now.microsecond

def func_2(name):
    func_1('function func_2')
    now = datetime.datetime.now()
    print "Bye, world"
    print "Current second: %d" % now.second
    print "Current microsecond: %d" % now.microsecond

if __name__ == '__main__':
    p = Process(target=func_2, args=('bob',))
    p.start()
    p.join()

---

我得到了微秒的差异。有没有办法同时执行这两个命令？任何帮助都将不胜感激。

我不确定这是否会在同时执行，但我认为这会让你离得更近

from multiprocessing import Process
import os
import datetime


def func_1(title):
    now = datetime.datetime.now()
    print "hello, world"
    print "Current second: %d" % now.second
    print "Current microsecond: %d" % now.microsecond


def func_2(name):
    now = datetime.datetime.now()
    print "Bye, world"
    print "Current second: %d" % now.second
    print "Current microsecond: %d" % now.microsecond


if __name__ == '__main__':
    procs = []
    procs.append(Process(target=func_2, args=('bob',)))
    procs.append(Process(target=func_1, args=('sir',)))
    map(lambda x: x.start(), procs)
    map(lambda x: x.join(), procs)

这（1）通常是不可能的（确切的）部分，（2）不是Python擅长的。如果您确实需要微秒级的执行精度，请使用C或ASM，但这是一种比忙于在两个不同进程中等待约定的开始时间更接近的方法：

from multiprocessing import Process
import os
import datetime
from time import time

def func_1(title):
    now = datetime.datetime.now()
    print "hello, world"
    print "Current second: %d" % now.second
    print "Current microsecond: %d" % now.microsecond

def func_2(name):
    now = datetime.datetime.now()
    print "Bye, world"
    print "Current second: %d" % now.second
    print "Current microsecond: %d" % now.microsecond

def start_f1(name):
    while time() < start_time: pass
    func_1(name)

def start_f2(name):
    while time() < start_time: pass
    func_2(name)        

if __name__ == '__main__':
    procs = []
    procs.append(Process(target=start_f2, args=('bob',)))
    procs.append(Process(target=start_f1, args=('sir',)))
    start_time = time() + 10
    map(lambda x: x.start(), procs)
    map(lambda x: x.join(), procs)

来自多处理导入进程的

导入操作系统
导入日期时间
从时间导入时间
def func_1（标题）：
now=datetime.datetime.now（）
打印“你好，世界”
打印“当前秒：%d”%now.second
打印“当前微秒：%d”%now.microsecond
def func_2（名称）：
now=datetime.datetime.now（）
打印“再见，世界”
打印“当前秒：%d”%now.second
打印“当前微秒：%d”%now.microsecond
def start_f1（名称）：
while time（）<开始时间：通过
func_1（姓名）
def start_f2（名称）：
while time（）<开始时间：通过
func_2（姓名）
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
过程=[]
append（进程（target=start\u f2，args=（'bob'，））
procs.append（进程（target=start\u f1，args=（'sir'，））
开始时间=时间（）+10
映射（lambda x:x.start（），procs）
映射（lambda x:x.join（），procs）

CPython

本身就是单线程的（谷歌“全局解释器锁”）。要想获得理论上的机会，你需要一个多核处理器，但即便如此，也只有一个运行在非常低级别的操作系统才能做到这一点，即使这样，你也需要特殊的硬件。。实际上，您所要求的是不可能的。

在编写以下内容的计算机上，此代码始终打印出相同的时间戳：

#! /usr/bin/env python3
from multiprocessing import Barrier, Lock, Process
from time import time
from datetime import datetime

def main():
    synchronizer = Barrier(2)
    serializer = Lock()
    Process(target=test, args=(synchronizer, serializer)).start()
    Process(target=test, args=(synchronizer, serializer)).start()

def test(synchronizer, serializer):
    synchronizer.wait()
    now = time()
    with serializer:
        print(datetime.fromtimestamp(now))

if __name__ == '__main__':
    main()

---

从理论上讲，完全相同的时间是不可能的——问题是允许的误差幅度有多大。在你的情况下，我猜你想在同一微秒开始它们？我不喜欢这样的答案，所以这只是一个评论，但我认为，在当今地球上流行的系统上，不幸的是，这是不可能的。我相信这是你在标准CPython中不做任何“实时”的情况下所能得到的最接近的结果扩展名@COpython抱歉，仍然有400ms的差异。@Mr.Calm，您可以将两个函数放在一个类中，然后在构造函数中获得

，然后两个函数将具有相同的时间戳。。。除此之外，没有其他方法可以更进一步：-/问题特别提到了避开GIL的多处理模块，因此您的答案的这一部分是无效的…也许GIL部分是无效的，但多处理模块依赖于OS调度器，它将以软件和顺序进行调度。您将需要两个处理器对相同的硬件中断做出反应，如果没有自定义硬件，您将无法获得相同的硬件中断。我收到此错误，
ImportError:cannotimport name Barrier
，并且我是此线程的新手，我尝试导入
Barrier
无法获得它。我认为这不是天生的package@Mr.Calm：尝试使用最新版本的Python（3.3版）来使用
Barrier
。派对有点晚了，但是@noctiskytower为什么在这里使用序列化程序？我似乎得到了类似的结果，只是根本不使用它。它的动机是什么？@clifgray
print
函数在显示字符串之前不会构造字符串。有几个步骤可以替代。
序列化程序
旨在确保所有这些步骤本质上都是原子的。我使用了这个想法，我让我的进程在10毫秒内一致运行。你认为这就是极限吗？知道如何进一步改进它吗？@clifgray编写一个C扩展可以稍微改进这一点，使用Barrier而不是繁忙的等待（请参阅公认的答案；仅限python3）。在操作系统方面，您还可以做一些事情，例如调整进程调度器。但是，如果10毫秒的差异对于您的用例来说还不够好，我怀疑这是否会有帮助，因为您之后所做的任何实际工作都不会保持同步（至少没有您的干预）。当您想要同步的实际操作仍然相隔毫秒或更长时间时，从同一微秒开始有什么好处？