Process 需要帮助在python 3中将time.sleep与多处理结合起来吗

使用python 3制作基于回合的游戏。我想要2个角色（敌人和敌人）进行攻击，根据随机+速度暂停，然后如果他们还活着，再次攻击

我遇到的问题是时间。睡眠冻结两个模块，而不是1个或另一个。有什么建议可以使这项工作更有效吗

from multiprocessing import Process
import time
import random

def timing1():  
    speed=60#SPEED IS NORMALLY A KEY FROM LIST, USING 60 FOR EXAMPLE  
    sleeptime=36/((random.randint(1,20)+speed)/5)  
    print (sleeptime)  
    time.sleep(sleeptime)  
    input('HERO ACTION')  

def timing2():  
    speed=45  
    sleeptime=36/((random.randint(1,20)+speed)/5)  
    print (sleeptime)  
    time.sleep(sleeptime)  
    input('FOE ACTION')  

if __name__ == '__main__':  
    p1=Process(target=timing1)  
    p1.start()  
    p2=Process(target=timing2)  
    p2.start()  
    p1.join()  
    p2.join()

---

在单圈之后，进程将在代码中退出。主进程通过对两个进程调用

.join（）

来等待它们退出，即

time。sleep（）

不会冻结其他进程

在为True时添加

：

在

计时*（）

函数的顶部进行多次移动

这里不需要多个进程。您可以使用线程甚至单个线程来实现turns

来详细说明J.F

我对线程的一般建议是，只有在绝对必要时才引入线程

• 您实际上是在低级别I/O上阻塞，除了使用本机线程之外，别无选择
• 您正在达到计算极限，需要使用更多的内核，在这种情况下，python由于其强大的性能可能会对您不利

另一种方法是，使用一个库，该库提供类似或的调度器，而不依赖本机线程来调度事件

gevent

您可以在编写游戏时考虑线程模型，但不必担心线程之间的资源争用。 在您的示例中使用gevent版本的like sleep时，您必须牢记这一点

import random
import gevent


def hero():
    speed = 60
    sleeptime = 36 / ((random.randint(1, 20) + speed) / 5)
    print (sleeptime)
    gevent.sleep(sleeptime)
    input('HERO ACTION')


def foe():
    speed = 45
    sleeptime = 36 / ((random.randint(1, 20) + speed) / 5)
    print (sleeptime)
    gevent.sleep(sleeptime)
    input('FOE ACTION')


if __name__ == "__main__":
    heroThread = gevent.Greenlet(hero)
    foeThread = gevent.Greenlet(foe)

    heroThread.start()
    foeThread.start()

    gevent.joinall([heroThread, foeThread])

import random
from twisted.internet import reactor


def heroAction():
    input('HERO ACTION')


def heroStart():
    speed = 60
    sleeptime = 36 / ((random.randint(1, 20) + speed) / 5)
    print (sleeptime)
    reactor.callLater(sleeptime, heroAction)


def foeAction():
    input('FOE ACTION')


def foeStart():
    speed = 45
    sleeptime = 36 / ((random.randint(1, 20) + speed) / 5)
    print (sleeptime)
    reactor.callLater(sleeptime, foeAction)


if __name__ == "__main__":
    # Call when the reactor has started.
    reactor.callWhenRunning(heroStart)
    reactor.callWhenRunning(foeStart)
    reactor.run()

twisted

提供一个事件反应器，它是用纯python编写的，并且不伪装成比单线程事件反应器（也称为单线程事件反应器）更多或更少的东西。 这需要对您的示例进行更大的重写

import random
import gevent


def hero():
    speed = 60
    sleeptime = 36 / ((random.randint(1, 20) + speed) / 5)
    print (sleeptime)
    gevent.sleep(sleeptime)
    input('HERO ACTION')


def foe():
    speed = 45
    sleeptime = 36 / ((random.randint(1, 20) + speed) / 5)
    print (sleeptime)
    gevent.sleep(sleeptime)
    input('FOE ACTION')


if __name__ == "__main__":
    heroThread = gevent.Greenlet(hero)
    foeThread = gevent.Greenlet(foe)

    heroThread.start()
    foeThread.start()

    gevent.joinall([heroThread, foeThread])

import random
from twisted.internet import reactor


def heroAction():
    input('HERO ACTION')


def heroStart():
    speed = 60
    sleeptime = 36 / ((random.randint(1, 20) + speed) / 5)
    print (sleeptime)
    reactor.callLater(sleeptime, heroAction)


def foeAction():
    input('FOE ACTION')


def foeStart():
    speed = 45
    sleeptime = 36 / ((random.randint(1, 20) + speed) / 5)
    print (sleeptime)
    reactor.callLater(sleeptime, foeAction)


if __name__ == "__main__":
    # Call when the reactor has started.
    reactor.callWhenRunning(heroStart)
    reactor.callWhenRunning(foeStart)
    reactor.run()

请注意，扭曲反应器将不会在无事可做时关闭，这是明确留给程序员的

推出自己的

出于学习的目的，编写自己的调度程序可能会很有趣，或者您可能在游戏中有类似公平性的要求。

---

一个好的起点是寻找灵感。

谢谢。这是一个新手，但要掌握它。