Проблемы с потоками Python начального уровня
-
20-08-2019 - |
Вопрос
Как новичок в разработке графического интерфейса на Python (с pyGTK), я только начал изучать многопоточность.Чтобы проверить свои навыки, я написал небольшой простой интерфейс GTK с кнопкой «старт/стоп».Цель состоит в том, чтобы при щелчке по нему запускался поток, который быстро увеличивал число в текстовом поле, сохраняя при этом отзывчивость графического интерфейса.
У меня графический интерфейс работает нормально, но у меня проблемы с потоками.Вероятно, это простая проблема, но я думаю о жареном на сегодня.Ниже я вставил сначала обратную ссылку из интерпретатора Python, а затем код.Вы можете пойти в http://drop.io/pxgr5id чтобы скачать его.Я использую bzr для контроля версий, поэтому, если вы хотите внести изменения и повторно удалить их, зафиксируйте изменения.Я также вставляю код в http://dpaste.com/113388/ потому что он может иметь номера строк, и эта уценка вызывает у меня головную боль.
Обновление от 27 января, 15:52 EST:Слегка обновленный код можно найти здесь: http://drop.io/threagui/asset/thread-gui-rev3-tar-gz
Выслеживать
crashsystems@crashsystems-laptop:~/Desktop/thread-gui$ python threadgui.pybtnStartStop clicked
Traceback (most recent call last):
File "threadgui.py", line 39, in on_btnStartStop_clicked
self.thread.stop()
File "threadgui.py", line 20, in stop
self.join()
File "/usr/lib/python2.5/threading.py", line 583, in join
raise RuntimeError("cannot join thread before it is started")
RuntimeError: cannot join thread before it is started
btnStartStop clicked
threadStop = 1
btnStartStop clicked
threadStop = 0
btnStartStop clicked
Traceback (most recent call last):
File "threadgui.py", line 36, in on_btnStartStop_clicked
self.thread.start()
File "/usr/lib/python2.5/threading.py", line 434, in start
raise RuntimeError("thread already started")
RuntimeError: thread already started
btnExit clicked
exit() called
Код
#!/usr/bin/bash
import gtk, threading
class ThreadLooper (threading.Thread):
def __init__ (self, sleep_interval, function, args=[], kwargs={}):
threading.Thread.__init__(self)
self.sleep_interval = sleep_interval
self.function = function
self.args = args
self.kwargs = kwargs
self.finished = threading.Event()
def stop (self):
self.finished.set()
self.join()
def run (self):
while not self.finished.isSet():
self.finished.wait(self.sleep_interval)
self.function(*self.args, **self.kwargs)
class ThreadGUI:
# Define signals
def on_btnStartStop_clicked(self, widget, data=None):
print "btnStartStop clicked"
if(self.threadStop == 0):
self.threadStop = 1
self.thread.start()
else:
self.threadStop = 0
self.thread.stop()
print "threadStop = " + str(self.threadStop)
def on_btnMessageBox_clicked(self, widget, data=None):
print "btnMessageBox clicked"
self.lblMessage.set_text("This is a message!")
self.msgBox.show()
def on_btnExit_clicked(self, widget, data=None):
print "btnExit clicked"
self.exit()
def on_btnOk_clicked(self, widget, data=None):
print "btnOk clicked"
self.msgBox.hide()
def on_mainWindow_destroy(self, widget, data=None):
print "mainWindow destroyed!"
self.exit()
def exit(self):
print "exit() called"
self.threadStop = 1
gtk.main_quit()
def threadLoop(self):
# This will run in a thread
self.txtThreadView.set_text(str(self.threadCount))
print "hello world"
self.threadCount += 1
def __init__(self):
# Connect to the xml GUI file
builder = gtk.Builder()
builder.add_from_file("threadgui.xml")
# Connect to GUI widgets
self.mainWindow = builder.get_object("mainWindow")
self.txtThreadView = builder.get_object("txtThreadView")
self.btnStartStop = builder.get_object("btnStartStop")
self.msgBox = builder.get_object("msgBox")
self.btnMessageBox = builder.get_object("btnMessageBox")
self.btnExit = builder.get_object("btnExit")
self.lblMessage = builder.get_object("lblMessage")
self.btnOk = builder.get_object("btnOk")
# Connect the signals
builder.connect_signals(self)
# This global will be used for signaling the thread to stop.
self.threadStop = 1
# The thread
self.thread = ThreadLooper(0.1, self.threadLoop, (1,0,-1))
self.threadCounter = 0
if __name__ == "__main__":
# Start GUI instance
GUI = ThreadGUI()
GUI.mainWindow.show()
gtk.main()
Решение
Потоковая обработка с помощью PyGTK немного сложна, если вы хотите сделать это правильно.По сути, вам не следует обновлять графический интерфейс из любого другого потока, кроме основного (обычное ограничение в библиотеках графического интерфейса).Обычно это делается в PyGTK с использованием механизма сообщений в очереди (для связи между рабочими процессами и графическим интерфейсом), которые периодически читаются с использованием функции таймаута.После того, как я провел презентацию по этой теме в своем местном LUG, вы можете получить пример кода для этой презентации на сайте Репозиторий кода Google.Посмотри на MainWindow
класс в forms/frmmain.py
, специально для метода _pulse()
и что сделано в on_entry_activate()
(там запускается поток плюс создается таймер простоя).
def on_entry_activate(self, entry):
text = entry.get_text().strip()
if text:
store = entry.get_completion().get_model()
if text not in [row[0] for row in store]:
store.append((text, ))
thread = threads.RecommendationsFetcher(text, self.queue)# <- 1
self.idle_timer = gobject.idle_add(self._pulse)# <- 2
tv_results = self.widgets.get_widget('tv_results')
model = tv_results.get_model()
model.clear()
thread.setDaemon(True)# <- 3
progress_update = self.widgets.get_widget('progress_update')
progress_update.show()
thread.start()# <- 4
Таким образом, приложение обновляет графический интерфейс, когда он «простаивает» (по средствам GTK), не вызывая зависаний.
- 1:создать тему
- 2:создать таймер простоя
- 3:демонизировать поток, чтобы приложение можно было закрыть, не дожидаясь завершения потока
- 4:начать ветку
Другие советы
Обычно лучше избегать потоков, когда это возможно.Очень сложно правильно написать многопоточное приложение, и еще труднее убедиться, что вы все сделали правильно.Поскольку вы пишете приложение с графическим интерфейсом, вам легче представить, как это сделать, поскольку вам уже нужно писать приложение в асинхронной среде.
Важно понимать, что приложение с графическим интерфейсом практически ничего не делает.Большую часть времени он проводит в ожидании, пока ОС сообщит ему, что что-то произошло.Вы можете сделать много чего в это время простоя, если знаете, как писать долго выполняющийся код, чтобы он не блокировался.
Вы можете решить исходную проблему, используя тайм-аут;сообщая вашей платформе графического интерфейса о необходимости обратного вызова некоторой функции после задержки, а затем сбрасывая эту задержку или запуская другой отложенный вызов.
Другой распространенный вопрос — как общаться по сети в приложении с графическим интерфейсом.Сетевые приложения похожи на приложения с графическим интерфейсом в том смысле, что они долго ждут.Используя инфраструктуру сетевого ввода-вывода (например, витой) упрощает совместное ожидание обеих частей вашего приложения, а не конкурентное, и снова устраняет необходимость в дополнительных потоках.
Длительные вычисления можно записывать итеративно, а не синхронно, и вы можете выполнять обработку, пока графический интерфейс простаивает.Вы можете использовать генератор, чтобы сделать это довольно легко в Python.
def long_calculation(param, callback):
result = None
while True:
result = calculate_next_part(param, result)
if calculation_is_done(result):
break
else:
yield
callback(result)
Вызов long_calculation
даст вам объект-генератор и вызов .next()
на объекте-генераторе будет запускать генератор до тех пор, пока он не достигнет либо yield
или return
.Вы бы просто сказали инфраструктуре графического интерфейса вызвать long_calculation(some_param, some_callback).next
когда у него будет время, и в конечном итоге ваш обратный вызов будет вызван с результатом.
Я не очень хорошо знаю GTK, поэтому не могу сказать вам, какие функции goject вам следует вызывать.Однако благодаря этому объяснению вы сможете найти необходимые функции в документации или, на худой конец, спросить на соответствующем IRC-канале.
К сожалению, хорошего общего ответа не существует.Если вы уточните, что именно вы пытаетесь сделать, будет легче объяснить, почему вам не нужны потоки в этой ситуации.
Вы не можете перезапустить остановленный объект потока;не пытайся.Вместо этого создайте новый экземпляр объекта, если вы хотите перезапустить его после того, как он действительно остановлен и присоединен.
Я экспериментировал с разными инструментами, помогающими навести порядок в работе с потоками, обработкой бездействия и т. д.
make_idle — это декоратор функции, который позволяет вам совместно запускать задачу в фоновом режиме.Это хорошая золотая середина между чем-то достаточно коротким, чтобы запускаться один раз в потоке пользовательского интерфейса и не влиять на скорость отклика приложения, и выполнением полного потока в специальной синхронизации.Внутри декорированной функции вы используете «yield», чтобы передать обработку обратно в графический интерфейс, чтобы он мог оставаться отзывчивым, и в следующий раз, когда пользовательский интерфейс будет простаивать, он возобновит вашу функцию с того места, на котором вы остановились.Итак, чтобы начать, вы просто вызываете Idle_add к декорированной функции.
def make_idler(func):
"""
Decorator that makes a generator-function into a function that will
continue execution on next call
"""
a = []
@functools.wraps(func)
def decorated_func(*args, **kwds):
if not a:
a.append(func(*args, **kwds))
try:
a[0].next()
return True
except StopIteration:
del a[:]
return False
return decorated_func
Если вам нужно выполнить немного больше обработки, вы можете использовать контекстный менеджер для блокировки потока пользовательского интерфейса, когда это необходимо, чтобы сделать код немного безопаснее.
@contextlib.contextmanager
def gtk_critical_section():
gtk.gdk.threads_enter()
try:
yield
finally:
gtk.gdk.threads_leave()
с этим ты можешь просто
with gtk_critical_section():
... processing ...
Я еще не закончил с этим, но, совмещая работу исключительно в режиме ожидания и исключительно в потоке, у меня есть декоратор (еще не протестированный, поэтому не опубликованный), с помощью которого вы можете сказать ему, нужно ли запускать следующий раздел после выхода. во время простоя пользовательского интерфейса или в потоке.Это позволит выполнить некоторую настройку в потоке пользовательского интерфейса, переключиться на новый поток для выполнения фоновых задач, а затем переключиться на время простоя пользовательского интерфейса для очистки, сводя к минимуму необходимость в блокировках.
Я не рассматривал подробно ваш код.Но я вижу два решения вашей проблемы:
Не используйте нити вообще.Вместо этого используйте тайм-аут, например:
import gobject
i = 0
def do_print():
global i
print i
i += 1
if i == 10:
main_loop.quit()
return False
return True
main_loop = gobject.MainLoop()
gobject.timeout_add(250, do_print)
main_loop.run()
При использовании потоков вы должны убедиться, что ваш код графического интерфейса вызывается только из одного потока одновременно, защитив его следующим образом:
import threading
import time
import gobject
import gtk
gtk.gdk.threads_init()
def run_thread():
for i in xrange(10):
time.sleep(0.25)
gtk.gdk.threads_enter()
# update the view here
gtk.gdk.threads_leave()
gtk.gdk.threads_enter()
main_loop.quit()
gtk.gdk.threads_leave()
t = threading.Thread(target=run_thread)
t.start()
main_loop = gobject.MainLoop()
main_loop.run()