Как я могу асинхронно обрабатывать xml в python?

ParseFile, как мы заметили, просто "проглатывает" все - это не годится для инкрементного синтаксического анализа, который вы хотите сделать! Таким образом, просто загружайте файл в синтаксический анализатор понемногу, убедившись, что условно передаете управление другим потокам по мере продвижения, например:

while True:
  data = f.read(BUFSIZE)
  if not data:
    p.Parse('', True)
    break
  p.Parse(data, False)
  time.sleep(0.0)

вызов time.sleep(0.0) — это способ Python сказать «уступать другим потокам, если они готовы и ожидают»; метод Parse задокументирован здесь.

Второй момент: забудьте о блокировках для этого использования! -- вместо этого используйте Queue.Queue, это по своей сути потокобезопасный и почти всегда лучший и самый простой способ координировать несколько потоков в Python. Просто создайте экземпляр Queue q, q.put(name) на нем и заблокируйте рабочие потоки на q.get(), ожидая выполнения дополнительной работы — это НАСТОЛЬКО просто!

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

Я не слишком уверен в этой проблеме. Я предполагаю, что вызов ParseFile блокируется, и из-за GIL выполняется только поток синтаксического анализа. Вместо этого можно было бы использовать multiprocessing. В любом случае, он предназначен для работы с очередями.

Вы создаете Process и можете передать ему Queue:

import sys, time
import xml.parsers.expat
import multiprocessing
import Queue

def do_expat(q):
    p = xml.parsers.expat.ParserCreate()

    def start_handler(name, attrs):
        q.put(name)

    p.StartElementHandler = start_handler
    p.buffer_text = True
    print("opening {0}".format(sys.argv[1]))
    with open(sys.argv[1]) as f:
        print("file is open")
        p.ParseFile(f)
        print("parsing complete")

if __name__ == '__main__':
    q = multiprocessing.Queue()
    process = multiprocessing.Process(target=do_expat, args=(q,))
    process.start()

    elements = []
    while True:
        while True:
            try:
                elements.append(q.get_nowait())
            except Queue.Empty:
                break

        print elements
        time.sleep(1)

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

Единственное, что я вижу неправильно, это то, что вы одновременно обращаетесь к q из разных потоков - без блокировки, как вы действительно пишете. Это напрашивается на неприятности - и вы, вероятно, получаете проблемы в виде блокировки интерпретатора Python. :)

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

import sys, time
import xml.parsers.expat
import threading

q = []
q_lock = threading.Lock() <---

def start_handler(name, attrs):
    q_lock.acquire() <---
    q.append(name)
    q_lock.release() <---

def do_expat():
    p = xml.parsers.expat.ParserCreate()
    p.StartElementHandler = start_handler
    p.buffer_text = True
    print("opening {0}".format(sys.argv[1]))
    with open(sys.argv[1]) as f:
        print("file is open")
        p.ParseFile(f)
        print("parsing complete")


t = threading.Thread(group=None, target=do_expat)
t.start()

while True:
    q_lock.acquire() <---
    print(q)
    q_lock.release() <---
    time.sleep(1)

Видите ли, это было очень просто, мы просто создали переменную блокировки для защиты нашего объекта, и получали эту блокировку каждый раз, прежде чем использовать объект, и освобождали каждый раз после того, как мы закончили нашу задачу над объектом. Таким образом мы гарантировали, что q.append(name) никогда не перекроется с print(q).

(В более новых версиях Python также есть синтаксис «with ....», который помогает вам не снимать блокировки, не закрывать файлы или другие очистки, о которых часто забывают.)

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