Як запустити асинхронні завдання в програмах Introspection Python GObject

Я пишу програму Python + GObject, якій потрібно прочитати нетривіальну кількість даних з диска при запуску. Дані зчитуються синхронно, і для завершення операції зчитування потрібно близько 10 секунд, протягом цього часу завантаження інтерфейсу затримується.

Я хотів би виконати завдання асинхронно і отримувати сповіщення, коли воно буде готове, не блокуючи інтерфейс користувача, більш-менш схоже:

def take_ages():
    read_a_huge_file_from_disk()

def on_finished_long_task():
    print "Finished!"

run_long_task(task=take_ages, callback=on_finished_long_task)
load_the_UI_without_blocking_on_long_task()

Раніше я використовував GTask для подібних речей, але я стурбований тим, що його код не торкнувся протягом 3 років, не кажучи вже про перенесене на GObject Introspection. Найголовніше, що він більше не доступний в Ubuntu 12.04. Тому я шукаю простий спосіб запустити завдання асинхронно, або стандартним способом Python, або стандартним способом GObject / GTK +.

Редагувати: ось якийсь код із прикладом того, що я намагаюся зробити. Я спробував, python-deferяк було запропоновано в коментарях, але мені не вдалося виконати довге завдання асинхронно і дозволити завантажувати інтерфейс користувача, не дочекавшись його завершення. Перегляньте тестовий код .

Чи є простий і широко застосовуваний спосіб виконання асинхронних завдань та отримання сповіщення про їх закінчення?

Ваша проблема є дуже поширеною, тому є багато рішень (навіси, черги з багатопроцесорною чи нарізною роботою, робочі пули, ...)

Оскільки це так часто, існує також рішення для вбудовування python (в 3.2, але підтримується тут: http://pypi.python.org/pypi/futures ) під назвою concurrent.futures. "Ф'ючерси" доступні багатьма мовами, тому python називає їх однаковими. Ось типові дзвінки (і ось ваш повний приклад , проте частина db замінена сном, див. Нижче, чому).

from concurrent import futures
executor = futures.ProcessPoolExecutor(max_workers=1)
#executor = futures.ThreadPoolExecutor(max_workers=1)
future = executor.submit(slow_load)
future.add_done_callback(self.on_complete)

Тепер до вашої проблеми, яка набагато складніше, ніж пропонує ваш простий приклад. Загалом у вас є теми або процеси для вирішення цього питання, але ось ваш приклад настільки складний:

1. Більшість реалізацій Python мають GIL, завдяки чому потоки не повністю використовують багатоядерні. Отже: не використовуйте теми з python!
2. Об'єкти, до яких потрібно повернутись slow_loadіз БД, не піддаються пікетуванню, це означає, що вони не можуть просто передаватися між процесами. Отже: ніякої багатопроцесорної роботи з результатами програмного центру!
3. Бібліотека, яку ви викликаєте (softwarecenter.db), не є безпечною для потоків (схоже, включає gtk або подібне), тому виклик цих методів у потоці призводить до дивної поведінки (у моєму тесті все, від 'працює' через 'ядро-дамп' до простого) кинути без результатів). Отже: жодних потоків із програмним центром.
4. Кожен асинхронний зворотний виклик у gtk не повинен робити нічого, крім програму зворотного виклику, який буде викликаний в основній програмі glib. Отже: ні print, не змінюється стан gtk, крім додавання зворотного дзвінка!
5. Gtk і подібні не працюють з потоками поза коробкою. Вам потрібно зробити threads_init, якщо ви телефонуєте в GTK або так метод, ви повинні захистити цей метод (в більш ранніх версіях це було gtk.gdk.threads_enter(), gtk.gdk.threads_leave()наприклад , див GStreamer :. Http://pygstdocs.berlios.de/pygst-tutorial/playbin. html ).

Я можу дати вам таку пропозицію:

1. Перезапишіть свої результати, slow_loadщоб повернути результати, які ви підбираєте, і використовувати ф'ючерси з процесами.
2. Перехід від програмного центру до python-apt або подібного (вам, мабуть, це не подобається). Але оскільки ви працюєте в Canonical, ви можете попросити розробників програмного центру безпосередньо додати документацію до свого програмного забезпечення (наприклад, заявивши, що це не безпечно для потоків), а ще краще, зробивши програмне забезпечення центром безпеки.

Як зауваження: рішення, надані іншими ( Gio.io_scheduler_push_job, async_call) , працюють, time.sleepале не з ними softwarecenter.db. Це тому, що все зводиться до ниток або процесів, і потоки не працюють з gtk і softwarecenter.

Ось ще один варіант використання програми планування вводу / виводу GIO (я ніколи не використовував його з Python, але приклад нижче, здається, працює нормально).

from gi.repository import GLib, Gio, GObject
import time

def slow_stuff(job, cancellable, user_data):
    print "Slow!"
    for i in xrange(5):
        print "doing slow stuff..."
        time.sleep(0.5)
    print "finished doing slow stuff!"
    return False # job completed

def main():
    GObject.threads_init()
    print "Starting..."
    Gio.io_scheduler_push_job(slow_stuff, None, GLib.PRIORITY_DEFAULT, None)
    print "It's running async..."
    GLib.idle_add(ui_stuff)
    GLib.MainLoop().run()

def ui_stuff():
    print "This is the UI doing stuff..."
    time.sleep(1)
    return True

if __name__ == '__main__':
    main()

Ви також можете використовувати GLib.idle_add (зворотний виклик) для виклику довгого виконуваного завдання, як тільки GLib Mainloop закінчить усі події більш високого пріоритету (які, на мою думку, включають створення інтерфейсу користувача).

Використовуйте інтроспективний GioAPI для читання файлу з його асинхронними методами, а під час початкового виклику виконайте це як тайм-аут, GLib.timeout_add_seconds(3, call_the_gio_stuff)де call_the_gio_stuffфункція повертається False.

Час очікування тут потрібно додати (хоча може знадобитися різна кількість секунд), оскільки, хоча виклики Gio async асинхронні, вони не блокують, це означає, що активність великого диска при читанні великого файлу чи великого кількість файлів, це може призвести до заблокованого інтерфейсу, оскільки користувальницький інтерфейс та введення / виведення все ще знаходяться в одному (головному) потоці.

Якщо ви хочете написати свої власні функції для асинхронізації та інтегруватися з основним циклом, використовуючи файли вводу / виводу файлів Python, вам доведеться написати код у вигляді GObject, або передавати зворотні дзвінки навколо, або використовувати, python-deferщоб допомогти вам Зроби це. Але найкраще використовувати Gio тут, оскільки це може принести вам багато приємних функцій, особливо якщо ви робите відкриті / зберігання файлів в UX.

Я думаю, що це зазначає, що це суперечливий спосіб зробити те, що запропонував @mhall.

По суті, у вас є запуск, а потім запустіть цю функцію async_call.

Якщо ви хочете побачити, як це працює, ви можете пограти з таймером сну і продовжувати натискати кнопку. Це по суті те саме, що відповідь @ mhall, за винятком того, що є приклад коду.

Виходячи з цього, це не моя робота.

import threading
import time
from gi.repository import Gtk, GObject



# calls f on another thread
def async_call(f, on_done):
    if not on_done:
        on_done = lambda r, e: None

    def do_call():
        result = None
        error = None

        try:
            result = f()
        except Exception, err:
            error = err

        GObject.idle_add(lambda: on_done(result, error))
    thread = threading.Thread(target = do_call)
    thread.start()

class SlowLoad(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Hello World")
        GObject.threads_init()        

        self.connect("delete-event", Gtk.main_quit)

        self.button = Gtk.Button(label="Click Here")
        self.button.connect("clicked", self.on_button_clicked)
        self.add(self.button)

        self.file_contents = 'Slow load pending'

        async_call(self.slow_load, self.slow_complete)

    def on_button_clicked(self, widget):
        print self.file_contents

    def slow_complete(self, results, errors):
        '''
        '''
        self.file_contents = results
        self.button.set_label(self.file_contents)
        self.button.show_all()

    def slow_load(self):
        '''
        '''
        time.sleep(5)
        self.file_contents = "Slow load in progress..."
        time.sleep(5)
        return 'Slow load complete'



if __name__ == '__main__':
    win = SlowLoad()
    win.show_all()
    #time.sleep(10)
    Gtk.main()

Додаткова примітка. Ви повинні дозволити іншому потоку закінчитись, перш ніж він належним чином закінчиться, або перевірити наявність файлу.блок у дочірній нитці.

Змінити на коментар до адреси:
Спочатку я забув GObject.threads_init(). Очевидно, коли кнопка спрацьовує, вона ініціалізувала набір різьби для мене. Це маскувало для мене помилку.

Зазвичай потоком є ​​створення вікна в пам'яті, негайно запустіть інший потік, коли потік завершить оновити кнопку. Я додав додатковий сон, перш ніж я навіть зателефонував на Gtk.main, щоб переконатися, що повне оновлення COULD запускається до того, як вікно було навіть намальоване. Я також прокоментував це, щоб переконатися, що запуск потоку зовсім не перешкоджає малюванню вікон.