多线程 - python多个线程锁可提高效率吗？

Question

[修改部分内容，sorry有两点原来我没有讲清楚，我重新修改了示例代码
1 使用多线程是因为网络IO
2 下面的三个资源都是线程共享的，所以要加锁
]
优化多线程的效率问题

原先的多线程结构如下：
建立一个锁，所有不安全的函数都用这个锁

class():

self.lock = threading.lock()

def out_to_file1(self): #第一个资源
    self.lock.acquire()
    f = open(file1)
    f.write()
    f.close()
    self.lock.release()
    
def out_to_file2(self):　#第二个资源
    self.lock.acquire()
    f = open(file2)
    f.write()
    f.close()
    self.lock.release()

def update_scan_count(self):　#第三个资源
    self.lock.acquire()
    self.scan_count += 1
    self.lock.release()
    
def _scan(self):　#每个线程的内部逻辑
    while self.queue.qsize() > 0 and self.is_continue:
    ...
    此处代码为处理网络IO(我使用多线程的原因)
    ...     
    out_to_file2()
    update_scan_count()
    out_to_file1()
    
def main(self):
    for i in range():
        t = threading.Thread(target=self._scan, name=str(i))
        setdaemon
        t.start()
        t.join()

现在考虑建立三个锁

lock1 = threading.lock()
lock2 = threading.lock()
lock3 = threading.lock()

分别锁住这三个资源

请问这样的效率会提高吗？有其他好的建议吗？多谢！
PS:求提供一些优秀的py多线程开源项目，想阅读学习一下！

Answer 1

Il est recommandé d'utiliser la file d'attenteQueue pour le traitement. Python3 a commencé à avoir un module concurrect.futures packagé, qui peut utiliser des multi-threads et des multi-processus comme des fonctions ordinaires.

Answer 2

Tout d'abord, le multi-threading de Python lui-même est 效率极低 en raison des limitations du mécanisme GIL（Global Interpreter Lock：全局解释锁） Sa fonction est simplement : 对于一个解释器，只能有一个线程在执行bytecode。
Donc, si vous voulez rechercher l'efficacité. du multi-threading au sens traditionnel, utilisons multi-processus (Python) dans le monde multiprocessing...

Ici, vous utilisez le multi-threading et utilisez des verrous pour contrôler les ressources publiques. Tout d'abord, le verrouillage de cette chose provoquera un blocage. Sans verrouillage, il n'y a pas de risque de blocage, mais il y aura des problèmes de synchronisation.

De plus, si différents threads exploitent différents fichiers, il n'y a pas de problème de synchronisation. Si le même fichier est exploité, je recommande d'utiliser Queue (file d'attente) pour le gérer.

En général, il est préférable d'utiliser un seul thread, car Pythonle multi-thread lui-même est inefficace et il n'est pas nécessaire de considérer les problèmes de synchronisation avec un seul thread. Si vous devez rechercher l’efficacité, l’utilisation de plusieurs processus doit également être prise en compte.

Answer 3

1. Vous n'avez pas besoin de verrou pour ouvrir différents fichiers

2. Vous n'avez pas besoin de verrou pour ouvrir le même fichier

L'efficacité des verrous est très faible. Essayez de remplacer « verrouillage » par « parallèle/file d'attente ».

Answer 4

Non, le multi-threading/verrouillage et autres réduiront les performances, seul le traitement asynchrone monothread améliorera les performances

Answer 5

Cela peut facilement provoquer une condition de blocage de la demande de possession, et d'autres conditions (demande exclusive, non préemptive, circulaire) provoqueront une impasse. Et le verrouillage renforce la sécurité des données, mais les performances diminueront inévitablement.