Преимущества скрученной пены - Асинхронный способ использования python suds soap lib

Я использую библиотеку python suds, чтобы сделать SOAP-клиент на основе локального файла wsdl. Моя цель - использовать Twisted в качестве backend, поэтому я запрашиваю SOAP-серверы асинхронным способом.

Я знаю, что эта тема была рассмотрена в разное время (here1, here2), но у меня все еще есть некоторые вопросы.

Я видел три разных подхода к использованию скрученных с пеной:

a) Применение этого патча в библиотеке suds.

b) Используйте twisted-suds, который является вилкой пены.

c) Под влиянием этот пост, я реализовал Client_Async suds-клиент, используя операцию twisted deferToThread (полностью работоспособный метод может здесь. Я также реализовал клиент suds Client_Sync, а также некоторые тесты)

# Init approach c) code
from suds.client import Client as SudsClient
from twisted.internet.threads import deferToThread

class MyClient(SudsClient):
   def handleFailure(self, f, key, stats):
        stats.stop_stamp(error=True)
        logging.error("%s. Failure: %s" % (key, str(f)))

    def handleResult(self, result, key, stats):
        stats.stop_stamp(error=False)
        success, text, res = False, None, None
        try:
            success = result.MessageResult.MessageResultCode == 200
            text = result.MessageResult.MessageResultText
            res = result.FooBar
        except Exception, err:
            pass
        logging.debug('%40s : %5s %10s \"%40s\"' % (key, success, text, res))
        logging.debug('%40s : %s' % (key, self.last_sent()))
        logging.debug('%40s : %s' % (key, self.last_received()))

def call(stats, method, service, key, *a, **kw):
    stats.start_stamp()
    logging.debug('%40s : calling!' % (key))
    result = service.__getattr__(method)(*a, **kw)
    return result

class Client_Async(MyClient):
    """ Twisted based async client"""
    def callRemote(self, stats, method, key, *args, **kwargs):
        logging.debug('%s. deferring to thread...' % key)
        d = deferToThread(call, stats, method, self.service, key, *args, **kwargs)
        d.addCallback(self.handleResult, key, stats)
        d.addErrback(self.handleFailure, key, stats)
        return d

class Client_Sync(MyClient):
    def callRemote(self, stats,  method, key, *args, **kwargs):
        result = None
        try:
            result = call(stats, method, self.service, key, *args, **kwargs)
        except Exception, err:
            self.handleFailure(err, key, stats)
        else:
            self.handleResult(result, key, stats)
# End approach c) code

Выполнение небольшого теста с использованием c) подхода указывает на преимущества модели Async:

-- Sync model using Client_Sync of approach c).
# python soap_suds_client.py -t 200 --sync
Total requests:800/800. Success:794 Errors:6
Seconds elapsed:482.0
Threads used:1

-- Async model using Client_Async of approach c).
# python soap_suds_client.py -t 200
Total requests:800/800. Success:790 Errors:10
Seconds elapsed:53.0
Threads used:11

Я не тестировал подходы a) или b), мой вопрос:

Что я действительно получаю от них, кроме использования только одного потока?

Ответ 1