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

Определенно потоки. Почему? Будущее является многоядерным. Почти любой новый ЦП имеет больше чем одно ядро или если это имеет всего один, это могло бы поддерживать гиперпоточность и таким образом притворство, что это имеет больше чем один. Для эффективного использования многоядерных центральных процессоров (и Intel планирует подойти к 32 ядрам в не до сих пор будущее) Вам нужны несколько потоков. При выполнении всех в одном основном потоке (обычно, поток UI является основным потоком), у пользователей будут центральные процессоры с 8, 16, и однажды 32 ядра и приложение никогда не используют больше чем один из них, IOW, который это выполняет очень, намного медленнее, чем это могло работать.

Фактический, если бы Вы планируете приложение в наше время, я ушел бы классического дизайна и думал бы об основных/ведомых отношениях. Ваш UI является ведущим устройством, это - только задача, должен взаимодействовать с пользователем. Это отображает данные пользователю и собирает ввод данных пользователем. Каждый раз, когда Вы, приложение должно "обработать любые данные" (даже небольшие количества и намного более важные большие), создают "задачу" любого вида, передайте эту задачу фоновому потоку и заставьте поток выполнить задачу, предоставив обратную связь UI (например, сколько процента это завершило или просто если задача все еще работает или нет, таким образом, UI может показать "происходящий работой индикатор"). Если возможно, разделяет задачу на многие маленькие, независимые подзадачи и выполняет больше чем один фоновый процесс, подавая одну подзадачу каждому из них. Тем путем Ваше приложение может действительно извлечь выгоду из многоядерного и стать быстрее, больше центральных процессоров ядер имеет.

На самом деле компании как Apple и Microsoft уже планируют то, как сделать их все еще самый единственный, распараллелил UIs, сами многопоточный. Даже с подходом выше, у Вас может однажды быть ситуация, что UI является самим узким местом. Фоновые процессы могут обработать данные намного быстрее, чем UI может представить их пользователю или попросить у пользователя входа. Сегодня много платформ UI мало ориентированы на многопотоковое исполнение, многие не ориентированные на многопотоковое исполнение вообще, но это изменится. Последовательная обработка (выполнение одной задачи за другим) является умирающим дизайном, параллельной обработкой (выполнение, многие определяют задачу сразу), то, куда будущее идет. Только посмотрите на графические адаптеры. Даже самая современная карта Nvidia имеет жалкую производительность при рассмотрении скорости обработки в МГц/ГГц одного только GPU. Как прибывает, это может разбить дерьмо из центральных процессоров когда дело доходит до 3D вычислений? Простой: Вместо того, чтобы вычислить один полигон указывают или один пиксель структуры за другим, он вычисляет многие из них параллельно (на самом деле целый набор одновременно) и тот способ, которым он достигает пропускной способности, которая все еще делает крик центральных процессоров. Например, ATI X1900 (для именования конкурента также) имеет 48 единиц программы построения теней!

Я думаю delayedresult то, что Вы ищете:

http://www.wxpython.org/docs/api/wx.lib.delayedresult-module.html

См. wxpython демонстрацию для примера.

Потоки - Позволяют нам использовать простое представление с 2 слоями (GUI, прикладная логика).

Работа прикладной логики должна быть сделана в отдельном потоке Python. Для событий Asynchronous, которые должны распространить до уровня GUI, используйте систему событий wx для регистрации пользовательских событий. Регистрация wx события ориентирована на многопотоковое исполнение, таким образом, Вы могли очевидно сделать это от нескольких контекстов.

Работа в другом направлении (GUI ввел события, инициировавшие прикладную логику), я нашел его лучше всего к списку дома пользовательской системой событий. Используйте модуль Очереди, чтобы иметь ориентированный на многопотоковое исполнение способ продвинуть и вытолкать объекты-события. Затем для каждой синхронной функции членства соедините его с асинхронной версией, которая продвигает синхронизирующий функциональный объект и параметры на очередь событий.

Это работает особенно хорошо, если только единственная операция логического уровня приложения может быть выполнена за один раз. Преимущество этой модели - то, что синхронизация проста - каждая синхронная функция работы в своем собственном контексте последовательно от запуска для окончания без беспокойства вытеснения или кодированного рукой получения. Вам не будут нужны блокировки для защиты критических разделов. В конце функции отправьте событие на уровень GUI, указывающий, что операция завершена.

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

редактирование - Забыло упоминать, что красота этого состоит в том, что возможно полностью отделить прикладную логику из кода GUI. Модульный принцип помогает, если Вы когда-нибудь решаете использовать другую платформу, или использование обеспечивают версию командной строки приложения. Чтобы сделать это, Вам будет нужен промежуточный диспетчер события (прикладной уровень-> GUI), который реализован уровнем GUI.

Потоки или процессы в зависимости от приложения. Иногда на самом деле лучше иметь GUI быть своей собственной программой и просто отправить асинхронные вызовы в другие программы, когда это должно проделать работу. Вы все еще закончите тем, что имели несколько потоков в GUI для контроля для результатов, но он может упростить вещи, если сделанная работа сложна и не непосредственно подключенная к GUI.

Работа с QT/C++ для Win32.

Мы делим главные единицы работы на различные процессы. GUI работает как отдельный процесс и может управлять/получать данными из процессов "рабочего" по мере необходимости. Работы приятно в сегодняшнем многоядерном мире.

Этот ответ не относится к вопросу OP относительно Python, но является большим количеством метаответа.

Простым способом являются потоки. Однако не каждая платформа имеет упреждающую поточную обработку (например, BREW, некоторые другие встроенные системы), Если возможно, просто разделите работу на блоки и сделайте это в НЕАКТИВНОМ обработчике событий.

Другая проблема с использованием потоков в BREW состоит в том, что это не очищает объекты стопки C++, таким образом, слишком легко пропустить память при простом уничтожении потока.

Для некоторых типов операций использование отдельных процессов имеет большой смысл. Назад в день, порождение процесса подверглось большому количеству издержек. С современными аппаратными средствами эти издержки являются едва даже вспышкой на экране. Это особенно верно при порождении длительного процесса.

Одно (спорное) преимущество состоит в том, что это - более простая концептуальная модель, чем потоки, которые могли бы привести к большему количеству удобного в сопровождении кода. Это может также сделать Ваш код легче протестировать, поскольку можно записать тестовые сценарии, которые осуществляют эти внешние процессы, не имея необходимость включать GUI. Некоторые могли бы даже утверждать, что это - основное преимущество.

В случае некоторого кода я когда-то продолжил работать, переключившись от потоков для разделения процессов, ведомых к сетевому сокращению более чем 5 000 строк кода, одновременно делая GUI более быстро реагирующим, код легче поддержать и протестировать, все при улучшении общей общей производительности.

Я использую потоки так основной цикл событий GUI никогда блоки.