如何在Python 2.6中获得线程安全打印？

Question

print在Python中不是线程安全的，根据thesearticles。

在后一篇文章中提供了Python 3的变通方法。

如何在Python 2.6中获得线程安全print？

Answer 1

有趣的问题 - 考虑到print声明中发生的所有事情，包括softspace属性的设置和检查，使其成为“线程安全”（实际上意味着：只打印的线程产生“对标准输出的控制“到另一个线程，当它打印一个换行符时，这样输出的每一行都保证来自一个线程）是一个有点挑战（通常的简单方法实际线程安全 - 委托一个单独的线程专有“拥有”并处理sys.stdout，通过Queue.Queue与其通信 - 并不是那么有用，因为问题是而不是线程安全[[即使是普通的print也没有风险o f崩溃以及最终在标准输出上出现的字符恰好是打印出来的字符]]，但需要在扩展的操作范围内在线程间互斥）。

所以，我想我做到了...：

import random 
import sys 
import thread 
import threading 
import time 

def wait(): 
    time.sleep(random.random()) 
    return 'W' 

def targ(): 
    for n in range(8): 
    wait() 
    print 'Thr', wait(), thread.get_ident(), wait(), 'at', wait(), n 

tls = threading.local() 

class ThreadSafeFile(object): 
    def __init__(self, f): 
    self.f = f 
    self.lock = threading.RLock() 
    self.nesting = 0 

    def _getlock(self): 
    self.lock.acquire() 
    self.nesting += 1 

    def _droplock(self): 
    nesting = self.nesting 
    self.nesting = 0 
    for i in range(nesting): 
     self.lock.release() 

    def __getattr__(self, name): 
    if name == 'softspace': 
     return tls.softspace 
    else: 
     raise AttributeError(name) 

    def __setattr__(self, name, value): 
    if name == 'softspace': 
     tls.softspace = value 
    else: 
     return object.__setattr__(self, name, value) 

    def write(self, data): 
    self._getlock() 
    self.f.write(data) 
    if data == '\n': 
     self._droplock() 

# comment the following statement out to get guaranteed chaos;-) 
sys.stdout = ThreadSafeFile(sys.stdout) 

thrs = [] 
for i in range(8): 
    thrs.append(threading.Thread(target=targ)) 
print 'Starting' 
for t in thrs: 
    t.start() 
for t in thrs: 
    t.join() 
print 'Done' 

到wait的调用是为了保证在没有该互斥担保的混沌混合输出（何处注释）。 随着包装，即上面的代码就像它看起来那样，和（至少）Python 2.5及以上（我相信这也可能运行在早期版本，但我没有任何轻松的手头来检查）输出为：

Thr W -1340583936 W at W 0 
Thr W -1340051456 W at W 0 
Thr W -1338986496 W at W 0 
Thr W -1341116416 W at W 0 
Thr W -1337921536 W at W 0 
Thr W -1341648896 W at W 0 
Thr W -1338454016 W at W 0 
Thr W -1339518976 W at W 0 
Thr W -1340583936 W at W 1 
Thr W -1340051456 W at W 1 
Thr W -1338986496 W at W 1 
    ...more of the same... 

的“序列化”效应（从而线程出现为“很好地循环”如上）是一个获取线程是当前打印的这一事实的副作用一个人比其他人（所有人都在等待！）严重得慢。注释掉wait的time.sleep，输出是代替

Thr W -1341648896 W at W 0 
Thr W -1341116416 W at W 0 
Thr W -1341648896 W at W 1 
Thr W -1340583936 W at W 0 
Thr W -1340051456 W at W 0 
Thr W -1341116416 W at W 1 
Thr W -1341116416 W at W 2 
Thr W -1338986496 W at W 0 
    ...more of the same... 

即更典型的“多线程输出” ...除了在输出的每一行从一个单一的线程来完全保证。

当然，，print 'ciao',将保持标准输出的“所有权”，直到它最终确实执行没有尾随逗号的打印，并且其他希望打印的线程可能会睡眠相当长一段时间（如何保证输出中的每一行都来自单线程？好吧，一个架构会积累部分线程来线程化本地存储，而不是实际将它们写入标准输出，并且仅在接收到\n ...时才写入...微妙地与softspace设置正确交错，我担心，但可能是可行的）。

Answer 2

我不知道是否有更好的方法，而不是这个锁定机制，但至少看起来很容易。我也不确定印刷是否真的不是线程安全的。

编辑：好吧现在测试我的自我，你是对的，你可以得到真正奇怪的输出。你不需要导入，它只是在那里，因为我使用Python 2.7。

from __future__ import print_function 
from threading import Lock 

print_lock = Lock() 
def save_print(*args, **kwargs): 
    with print_lock: 
    print (*args, **kwargs) 

save_print("test", "omg", sep='lol') 

Answer 3

问题是python使用NEWLINE打印和打印对象本身的单独操作码。最简单的解决方案可能是使用明确的换行符显式的sys.stdout.write。

Answer 4

通过实验，我发现了以下工作，简单，适合我的需要：

print "your string here\n", 

或者，包裹在一个函数，

def safe_print(content): 
    print "{0}\n".format(content), 

我的理解是，隐含的新行的正常print实际上是在单独的操作中输出到stdout，从而导致与其他print操作的竞争条件。通过删除这个隐含的换行符,，而不是在字符串中包含换行符，我们可以避免这个问题。

---

2017年编辑：这个答案已经开始拿起一些蒸汽，所以我只是想澄清。这实际上并不确切地使print“线程安全”。如果prints彼此间隔几微秒发生，则输出的顺序可能会错误。然而，这个做的做的是避免从并发线程执行的print语句产生乱码输出，这是大多数人在问这个问题时真正想要的。

这是一个测试，说明我的意思：

from concurrent.futures import ThreadPoolExecutor 


def normal_print(content): 
    print content 

def safe_print(content): 
    print "{0}\n".format(content), 


with ThreadPoolExecutor(max_workers=10) as executor: 
    print "Normal Print:" 
    for i in range(10): 
     executor.submit(normal_print, i) 

print "---" 

with ThreadPoolExecutor(max_workers=10) as executor: 
    print "Safe Print:" 
    for i in range(10): 
     executor.submit(safe_print, i) 

输出：

Normal Print: 
0 
1 
23 

4 
65 

7 
9 
8 
---- 
Safe Print: 
1 
0 
3 
2 
4 
5 
6 
7 
8 
9