关于python：使2个函数同时运行


Make 2 functions run at the same time

我试图让两个函数同时运行。

1
2
3
4
5
6
7
8
def func1():
    print 'Working'

def func2():
    print 'Working'

func1()
func2()

有人知道怎么做吗？

相关讨论

执行此操作：

1
2
3
4
5
6
7
8
9
10
11
from threading import Thread

def func1():
    print 'Working'

def func2():
    print 'Working'

if __name__ == '__main__':
    Thread(target = func1).start()
    Thread(target = func2).start()
相关讨论

关于线程处理的答案是好的，但是您需要对您想要做的事情更加具体一点。

如果您有两个同时使用大量CPU的函数，线程(在cpython中)可能会使您无处可逃。然后，您可能希望了解多处理模块，或者可能希望使用Jython/Ironpython。

如果CPU限制的性能是原因，那么您甚至可以在(非线程的)C中实现一些东西，并且比在Python中执行两个并行的东西更快。

如果没有更多的信息，很难找到一个好的答案。

一个选项，看起来它可以使两个函数同时运行时间，是使用threading模块(本答案中的示例)。

但是，作为正式的python文档，它有一点延迟页面描述。一个更好的尝试使用的模块是multiprocessing。

另外，还有其他的python模块可以用于异步执行(两段代码同时工作)。有关它们的一些信息以及选择它们的帮助，您可以阅读这个堆栈溢出问题。

其他用户对threading模块的评论

He might want to know that because of the Global Interpreter Lock
they will not execute at the exact same time even if the machine in
question has multiple CPUs. wiki.python.org/moin/GlobalInterpreterLock

号

—乔纳斯·埃尔夫斯特？2010年6月2日11:39

引用有关threading模块不工作的文档

CPython implementation detail: In CPython, due to the Global Interpreter
Lock, only one thread can execute Python code at once (even though
certain performance-oriented libraries might overcome this limitation).

If you want your application to make better use of the computational resources of multi-core machines, you are advised to use multiprocessing or concurrent.futures.ProcessPoolExecutor.
However, threading is still an appropriate model if you
want to run multiple I/O-bound tasks simultaneously.

号

相关讨论

这可以通过Ray优雅地完成，该系统允许您轻松地并行和分发您的Python代码。

要使您的示例并行，您需要使用@ray.remote decorator定义函数，然后使用.remote调用它们。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import ray

ray.init()

# Define functions you want to execute in parallel using
# the ray.remote decorator.
@ray.remote
def func1():
    print("Working")

@ray.remote
def func2():
    print("Working")

# Execute func1 and func2 in parallel.
ray.get([func1.remote(), func2.remote()])

。

如果func1()和func2()返回结果，则需要稍微重写上述代码，方法是将ray.get([func1.remote(), func2.remote()])替换为：

1
2
3
ret_id1 = func1.remote()
ret_id2 = func1.remote()
ret1, ret2 = ray.get([ret_id1, ret_id2])

。

与多处理模块或使用多线程相比，使用Ray有许多优点。特别是，相同的代码将在一台机器以及一组机器上运行。

有关Ray的更多优点，请参阅相关文章。

试试这个

1
2
3
4
5
6
7
8
9
10
11
12
from threading import Thread

def fun1():
    print("Working1")
def fun2():
    print("Working2")

t1 = Thread(target=fun1)
t2 = Thread(target=fun2)

t1.start()
t2.start()

号

相关讨论

我认为你试图传达的信息可以通过多重处理来实现。但是，如果您想通过线程来完成它，您可以这样做。这可能有帮助

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from threading import Thread
import time

def func1():
    print 'Working'
    time.sleep(2)

def func2():
    print 'Working'
    time.sleep(2)

th = Thread(target=func1)
th.start()
th1=Thread(target=func2)
th1.start()

与多进程不同，线程模块同时工作，但时间有点偏。下面的代码打印一个"1"和一个"2"。它们分别由不同的函数调用。我确实注意到，当打印到控制台时，它们的时间会略有不同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
   from threading import Thread

   def one():
       while(1 == num):
           print("1")
           time.sleep(2)

   def two():
       while(1 == num):
           print("2")
           time.sleep(2)


   p1 = Thread(target = one)
   p2 = Thread(target = two)

   p1.start()
   p2.start()

输出：(请注意，该空间用于打印之间的等待)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
   1
   2

   2
   1

   12

   21

   12

   1
   2

。

不确定是否有办法纠正这个问题，或者它是否重要。只是我注意到的。