Modification to to support threaded event loop

Josiah Carlson jcarlson at
Thu Nov 4 19:20:02 CET 2004

abpillai at (Anand Pillai) wrote:
> If you have ever used the asyncore module, you will realize that it's
> event loop does not have a programmable exit condition. It keeps
> looping till the channels in its socket map (a dictionary) are closed
> and don't have any pending reads/writes.

With the asyncore that will be included with Python 2.4, loop() has a
'count' argument.  Your 'programmable exit condition' is simple...

while not exit_condition_satisfied:

> If you are using Python threads in your application, by using either
> the threading or thread modules, adding asyncore capability on top of
> it is a bit tricky. The moment you call asyncore.loop after
> initializing your asyncore based client/server, it takes over the main
> thread. Hence, if you want to mix threaded classes (derived from
> threading.Thread) and asyncore in one program, the only recourse is to
> create and initialize all your thread objects first and call
> asyncore.loop as the last function in your main thread.
> However, with a small hack it is possible to get asyncore event loop
> running in its own thread, as shown below.

Here's an easier way to get asyncore running in its own thread, with
nearly all the functionality you mention, without having to subclass

def asyncore_loop(exit_condition, timeout=30.0,
                  use_poll=False, map=None):
    if map is None:
        map =
    while map and not exit_condition:
        asyncore.loop(timeout=30.0, use_poll=False, map=map, count=1)

exit_condition = []

threading.Thread(target=asyncore_loop, args=(exit_condition,)).start()

#to kill the thread...

> The following is a mixin class, which derives from threading.Thread
> and also overrides asyncore.loop in its 'run()' method.

[snip unnecessary code]

> Now you can initialize your asyncore based clients/servers and instead
> of calling 'asyncore.loop', do it as follows,

See the snippet I provide above.

> Perhaps this is worth a PEP for inclusion in Python 2.4?

Module and/or functionality additions do not require a PEP (from what I
understand).  Changing the behavior of the language, adding a builtin,
etc., that requires a PEP.

It is not going to make it into Python 2.4.  How would I know this? 
Because "no new functionality after the beta".  We're on beta 2, and
even small functionality additions that were pre-approved (but not
implemented) are not making it into 2.4.

What about for Python 2.5?  I doubt it would be added there either.  The
functionality is very simple to implement if you know what you are doing,
and doesn't require copying the internals of asyncore.loop to make it

 - Josiah

More information about the Python-list mailing list