Блокировка параллельной печати и записи

Question

У меня есть простой проект, где мне нужно распечатать информацию о параллельном продвижении, такую ​​как индикатор выполнения.

Каждый стержень имеет позицию, а курсор в терминале перемещается вверх и вниз в зависимости от положения бара.

Это хорошо работает, когда выполняется серийно, но это не удается при печати параллельно из-за проблем с гонкой. Я попытался использовать multiprocessing.Lock(), но безрезультатно.

Вот мой текущий код:

from __future__ import division 

import os, sys 
import signal 
from time import sleep 
from multiprocessing import Pool, freeze_support, Lock 

if os.name == 'nt': 
    import colorama # to support cursor up 
    colorama.init() 

_term_move_up = '\x1b[A' 

write_lock = Lock() 

class simple_bar(object): 
    def __init__(self, iterable, desc='', position=0): 
     signal.signal(signal.SIGINT, signal.SIG_IGN) # handles keyboardinterrupt 
     self.iterable = iterable 
     self.total = len(iterable) 
     self.n = 0 
     self.position = position 
     self.desc = desc 
     self.display() 

    def __iter__(self): 
     for obj in self.iterable: 
      yield obj 
      self.update() 

    def update(self, n=1): 
     self.n += n 
     self.display() 

    def display(self, fp=None, width=79): 
     if not fp: 
      fp = sys.stdout 

     with write_lock: 
      fp.write('\n' * self.position) 
      l_part = self.desc + ': ' 
      bar = l_part + '#' * int((self.n/self.total) * (width - len(l_part))) 
      fp.write('\r' + bar + ' ' * (width - len(bar))) 
      fp.write(_term_move_up * self.position) 
      fp.flush() 

def progresser(n):   
    text = "progresser #{}".format(n) 
    for i in simple_bar(range(5000), desc=text, position=n): 
     sleep(0.001) 

if __name__ == '__main__': 
    freeze_support() 
    L = list(range(3)) 
    Pool(len(L)).map(progresser, L) 

Последовательная альтернатива, которая работает хорошо, это дает правильный вывод, который должен быть получен в параллельной версии выше:

# Same code as above, except __main__ 

if __name__ == '__main__': 
    t_list = [simple_bar(range(5000), desc="progresser #{}".format(n), position=n) for n in xrange(3)] 
    for i in range(5000): 
     for t in t_list: 
      t.update() 

Я понятия не имею, что идет не так. Я использую Python 2.7.12 на Windows 7.

Ищу способ печати параллельно безопасно в многопроцессорных и идеально, но необязательно резьбы безопасно.

/EDIT: интересно, если я поставлю ждать (но достаточно большая) непосредственно перед печатью, то бруски печатаются в порядке:

# ... 
    def display(self, fp=None, width=79): 
     if not fp: 
      fp = sys.stdout 

     with write_lock: 
      sleep(1) # this fixes the issue by adding a delay 
      fp.write('\n' * self.position) 
      l_part = self.desc + ': ' 
      bar = l_part + '#' * int((self.n/self.total) * (width - len(l_part))) 
      fp.write('\r' + bar + ' ' * (width - len(bar))) 
      fp.write(_term_move_up * self.position) 
      fp.flush() 
# ... 

Я не знаю, какой вывод из этого следует.

Answer 1

Это может быть проблема с глобальной переменной блокировки. Когда вы создаете дочерний процесс в unix, у вас есть копия памяти родителя. В окнах, кажется, что это не так

Попробуйте этот код

from __future__ import division 
import os, sys 
import signal 
from time import sleep 
from multiprocessing import Pool, freeze_support, Lock 

if os.name == 'nt': 
    import colorama # to support cursor up 
    colorama.init() 

_term_move_up = '\x1b[A' 



class simple_bar(object): 
    def __init__(self, iterable, desc='', position=0): 
     signal.signal(signal.SIGINT, signal.SIG_IGN) # handles keyboardinterrupt 
     self.iterable = iterable 
     self.total = len(iterable) 
     self.n = 0 
     self.position = position 
     self.desc = desc 
     self.display() 

    def __iter__(self): 
     for obj in self.iterable: 
      yield obj 
      self.update() 

    def update(self, n=1): 
     self.n += n 
     self.display() 

    def display(self, fp=None, width=79): 
     if not fp: 
      fp = sys.stdout 

     with write_lock: 
      fp.write('\n' * self.position) 
      l_part = self.desc + ': ' 
      bar = l_part + '#' * int((self.n/self.total) * (width - len(l_part))) 
      fp.write('\r' + bar + ' ' * (width - len(bar))) 
      fp.write(_term_move_up * self.position) 
      fp.flush() 

def progresser(n): 
    text = "progresser #{}".format(n) 
    for i in simple_bar(range(5000), desc=text, position=n): 
     sleep(0.001) 

def init_child(lock_): 
    global write_lock 
    write_lock = lock_ 

if __name__ == '__main__': 
    write_lock = Lock() 
    L = list(range(3)) 
    pool = Pool(len(L), initializer=init_child, initargs=(write_lock,)) 
    pool.map(progresser, L) 

Answer 2

Необходимо добавить fp.flush() до write_lock.release().

несвязанные комментарии:

• Рассмотрим используя замок в качестве менеджера контекста (with write_lock... вместо ручного acquire() и release()) - что легче следовать, и менее подвержены ошибкам.
• Ни одна из версий не обрабатывает прерывания (Ctrl + C), вы можете захотеть изучить это.