如何使3个线程按顺序打印

Question

我需要制作3个线程来打印信号量颜色：此顺序为红色，黄色和绿色，之后，每个胎面必须随机睡眠N秒。必须为一个线程打印每种颜色，并且所有这些过程必须重复N次。

我已经尝试将lock.acquire（）和lock.release（）移出for循环但是不起作用=（

from termcolor import colored
import threading
import time
from random import randrange


def threadRed(n, lock, tempo):
    for i in range(n):
        lock.acquire()
        print(colored("red", 'grey', 'on_red', attrs=['dark', 'bold']))
        print(colored("I'm going to sleep for %d seconds," % tempo, 'red'))
        time.sleep(tempo)
        lock.release()


def threadYellow(n, lock, tempo):
    for i in range(n):
        lock.acquire()
        print(colored("yellow", 'grey', 'on_yellow', attrs=['dark', 'bold']))
        print(colored("I'm going to sleep for %d seconds," % tempo, 'yellow'))
        time.sleep(tempo)
        lock.release()


def threadGreen(n, lock, tempo):
    for i in range(n):
        lock.acquire()
        print(colored("green", 'grey', 'on_green', attrs=['dark', 'bold']))
        print(colored("I'm going to sleep for %d seconds," % tempo, 'green'))
        time.sleep(tempo)
        lock.release()


lock = threading.Lock()
repeticoes = 5
tempo = randrange(1, 11)
t_red = threading.Thread(target=threadRed, args=(repeticoes, lock, tempo))
tempo = randrange(1, 11)
t_yellow = threading.Thread(target=threadYellow, args=(repeticoes, lock, tempo))
tempo = randrange(1, 11)
t_green = threading.Thread(target=threadGreen, args=(repeticoes, lock, tempo))

t_red.start()
t_yellow.start()
t_green.start()
t_red.join()
t_yellow.join()
t_green.join()

简单地说，我的代码是打印：

但我需要这个是显示的结果：

Answer 1

好的，你想要的输出会杀死multi-threading的全部意义。

为什么？

线程有一个开头，一个执行序列和一个结论。它有一个指令指针，可以跟踪当前运行的上下文。

继续这一点，你的问题中的重点是同时运行多个线程，而不管function首先执行的事实。

你在想的是：

无论哪个线程首先完成，都以顺序方式运行线程，这不是multi-threading。在此之上，你在每个函数中使用lock.acquire() and lock.release()将灵魂带出多线程

答：如果你真的希望线程以顺序方式运行，你不应该在函数内部获取和释放线程，

一点变化：

from termcolor import colored
import threading
import time
from random import randrange


def threadRed(n, tempo):
    for i in range(n):
        # lock.acquire()
        print(colored("red", 'grey', 'on_red', attrs=['dark', 'bold']))
        print(colored("I'm going to sleep for %d seconds," % tempo, 'red'))
        time.sleep(tempo)
        # lock.release()


def threadYellow(n, tempo):
    for i in range(n):
        # lock.acquire()
        print(colored("yellow", 'grey', 'on_yellow', attrs=['dark', 'bold']))
        print(colored("I'm going to sleep for %d seconds," % tempo, 'yellow'))
        time.sleep(tempo)
        # lock.release()


def threadGreen(n, tempo):
    for i in range(n):
        # lock.acquire()
        print(colored("green", 'grey', 'on_green', attrs=['dark', 'bold']))
        print(colored("I'm going to sleep for %d seconds," % tempo, 'green'))
        time.sleep(tempo)
        # lock.release()


lock = threading.Lock()
repeticoes = 5
lock.acquire()
tempo = randrange(1, 11)
t_red = threading.Thread(target=threadRed, args=(repeticoes, tempo))
tempo = randrange(1, 11)
t_yellow = threading.Thread(target=threadYellow, args=(repeticoes, tempo))
tempo = randrange(1, 11)
t_green = threading.Thread(target=threadGreen, args=(repeticoes, tempo))
lock.release()
t_red.start()
t_yellow.start()
t_green.start()
t_red.join()
t_yellow.join()
t_green.join()

OUTPUT：

red
I'm going to sleep for 6 seconds,
yellow
I'm going to sleep for 4 seconds,
green
I'm going to sleep for 4 seconds,
yellow
I'm going to sleep for 4 seconds,
green
I'm going to sleep for 4 seconds,
red
I'm going to sleep for 6 seconds,
yellow
I'm going to sleep for 4 seconds,
green
I'm going to sleep for 4 seconds,
red
I'm going to sleep for 6 seconds,

Answer 2

不要试图使用threading.Lock()。 lock对象仅用于互斥（即，防止两个或多个线程同时访问相同的数据。）它不用于线程之间的通信。

IMO，最好的方法是使用三个Semaphore实例。 Python有一个类asyncio.Semaphore，但我对它的文档中的“不是线程安全”这个词感到有些困惑。我从未使用过该类，但它看起来像其他语言库中的信号量，用于线程之间的信号传递。

信号量就像一个包含零个或多个许可证的阻塞队列。许可证是抽象的;他们实际上并不存在。信号量只是计算在任何给定时刻它应该“包含”多少个。

调用者可以尝试向acquire()许可，这将减少计数并在计数大于零时立即返回，或者等到其他一些线程release()s允许否则。

所以这是你如何使用它：

制作三个空信号量（count == 0），每个线程一个，并为每个线程提供对其自身信号量的引用，并且还为下一个线程的信号量提供引用。然后每个线程应该循环：

for i in range(n):
    self.my_semaphore.acquire()        # thread waits here until signalled.
    print( ... )
    self.next_guys_semaphore.release() # signals the next guy.

在主线程创建了三个信号量和三​​个工作线程之后，什么都不会发生，因为所有三个工作者都将在acquire()中等待。那么，主线程需要做的最后一件事就是red_worker_semaphore.release()，然后他们应该按照正确的顺序一个接一个地开始运行。

Answer 3

我做到了！

谢谢大家提示！但我使用threading.Lock（）和threading.Event（）重新编写我的所有代码并且工作正常！

from termcolor import colored
import threading
import time
from random import randrange


lock = threading.Lock()
event = threading.Event()


def printThread(color):
    duration = randrange(1, 11)
    print(colored(color, 'grey', 'on_'+color, attrs=['dark', 'bold']))
    print(colored("I'm going sleep for %d seconds!," % duration, color))
    time.sleep(duration)

def threadRed(n):
    for i in range(n):
        lock.acquire()
        printThread("red")
        lock.release()
        event.set()
        event.wait()
        event.clear()


def threadYellow(n):
    for i in range(n):
        lock.acquire()
        printThread("yellow")
        lock.release()
        event.set()
        event.wait()
        event.clear()


def threadGreen(n):
    for i in range(n):
        lock.acquire()
        printThread("green")
        lock.release()
        event.set()
        event.wait()
        event.clear()



loop_count = 5

t_red = threading.Thread(target=threadRed, args=(loop_count,))

t_yellow = threading.Thread(target=threadYellow, args=(loop_count,))

t_green = threading.Thread(target=threadGreen, args=(loop_count,))


t_red.start()
t_yellow.start()
t_green.start()
t_red.join()
t_yellow.join()
t_green.join()

Answer 4

这是相同代码的另一个版本，但使用纯信号量，而不是事件

from termcolor import colored
import threading
import time
from random import randrange


semaforo1 = threading.Semaphore()
semaforo2 = threading.Semaphore()
semaforo3 = threading.Semaphore()



def printThread(color):
    duration = randrange(1, 11)
    print(colored(color, 'grey', 'on_'+color, attrs=['dark', 'bold']))
    print(colored("I'm going sleep for %d seconds!," % duration, color))
    time.sleep(duration)

def threadRed(n):
    semaforo2.acquire()
    semaforo3.acquire()
    for i in range(n):
        semaforo1.acquire()
        printThread("red")
        #semaforo1.release()
        semaforo2.release()


def threadYellow(n):
    for i in range(n):
        semaforo2.acquire()
        printThread("yellow")
        semaforo3.release()



def threadGreen(n):
    for i in range(n):
        semaforo3.acquire()
        printThread("green")
        semaforo1.release()




loop_count = 5

t_red = threading.Thread(target=threadRed, args=(loop_count,))

t_yellow = threading.Thread(target=threadYellow, args=(loop_count,))

t_green = threading.Thread(target=threadGreen, args=(loop_count,))


t_red.start()
t_yellow.start()
t_green.start()
t_red.join()
t_yellow.join()
t_green.join()