在这种情况下，如何用信号量或互斥锁替换队列

Question

我有 4 个线程从 4 个文本文件中读取，另外有一个线程写入 4 个线程已经读取，我使用了队列，那么如何使用信号量或互斥锁？

代码运行与队列：

import queue
import threading
from datetime import datetime

start_time = datetime.now()

def print_text(q, filename):
    for line in open(filename, encoding="utf8"):
        q.put(line.strip())
    q.put('--end--')

def print_result(q, count=0):
    while count:
        line = q.get()
        if line == '--end--':
            count -= 1
        else:
            print(line)

if __name__ == "__main__":
    filenames = ['file_1.txt', 'file_2.txt', 'file_3.txt', 'file_4.txt']
    q = queue.Queue()
    threads = [threading.Thread(target=print_text, args=(q, filename)) for filename in filenames]
    threads.append( threading.Thread(target=print_result, args=(q, len(filenames))) )
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
time_elapsed = datetime.now() - start_time
print('Time elapsed (hh:mm:ss.ms) {}'.format(time_elapsed))

我尝试用互斥锁解决：

import threading
import time
import random

mutex = threading.Lock()
class thread_one(threading.Thread):
    def run(self):
        global mutex
        print ("The first thread is now sleeping")
        time.sleep(random.randint(1, 5))
        print("First thread is finished")
        mutex.release()

class thread_two(threading.Thread):
    def run(self):
        global mutex
        print ("The second thread is now sleeping")
        time.sleep(random.randint(1, 5))
        mutex.acquire()
        print("Second thread is finished")

class thread_three(threading.Thread):
    def run(self):
        global mutex
        print ("The Three thread is now sleeping")
        time.sleep(random.randint(1, 5))
        mutex.acquire()
        print("Three thread is finished")

class thread_four(threading.Thread):
    def run(self):
        global mutex
        print ("The Four thread is now sleeping")
        time.sleep(random.randint(1, 5))
        mutex.acquire()
        print("Four thread is finished")

mutex.acquire()
t1 = thread_one()
t2 = thread_two()
t3 = thread_three()
t4 = thread_four()
t1.start()
t2.start()
t3.start()
t4.start()

Answer 1

import queue                    
import threading                

s = threading.Semaphore(5)
def print_text(s, q, filenames):
    with s:
        for line in open(filenames, encoding="utf8"):
            q.put(line.strip())
        q.put('--end--')

def print_result(q, count=0):   
    while count:                
        line = q.get()          
        if line == '--end--':   
            count -= 1          
        else:
            print(line)

if __name__ == "__main__":
    filenames = ['file_1.txt', 'file_2.txt', 'file_3.txt', 'file_4.txt']

    q = queue.Queue()    

    threads = [threading.Thread(target=print_text, args=(s, q, filename)) for filename in filenames]
    
    threads.append( threading.Thread(target=print_result, args=(q, len(filenames))) ) 

    for thread in threads:
        thread.start()
    
    for thread in threads:
        thread.join()

在这种情况下，如何用信号量或互斥锁替换队列

How can I replace the queue in this case with semaphore or mutex lock

python

multithreading

locking

mutex

python-multithreading