View on
MetaCPAN is shutting down
For details read Perl NOC. After June 25th this page will redirect to
Marc A. Lehmann > Coro > Coro::AnyEvent



Annotate this POD


New  2
Open  4
View/Report Bugs
Module Version: 6.514   Source  


Coro::AnyEvent - integrate threads into AnyEvent


 use Coro;
 use AnyEvent;
 # using both Coro and AnyEvent will automatically load Coro::AnyEvent

 # or load it manually for its utility functions:
 use Coro::AnyEvent;

 Coro::AnyEvent::sleep 5;     # block current thread for 5s
 Coro::AnyEvent::poll;        # poll for new events once
 Coro::AnyEvent::idle;        # block until process no longer busy
 Coro::AnyEvent::idle_upto 5; # same, but only up to 5 seconds

 Coro::AnyEvent::readable $fh, 60
    or die "fh didn't become readable within 60 seconds\n";


When one naively starts to use threads in Perl, one will quickly run into the problem that threads which block on a syscall (sleeping, reading from a socket etc.) will block all threads.

If one then uses an event loop, the problem is that the event loop has no knowledge of threads and will not run them before it polls for new events, again blocking the whole process.

This module integrates threads into any event loop supported by AnyEvent, combining event-based programming with coroutine-based programming in a natural way.

As of Coro 5.21 and newer, this module gets loaded automatically when AnyEvent initialises itself and Coro is used in the same process, thus there is no need to load it manually if you just want your threads to coexist with AnyEvent.

If you want to use any functions from this module, you of course still need to use Coro::AnyEvent, just as with other perl modules.

Also, this module autodetects the event loop used (by relying on AnyEvent) and will either automatically defer to the high-performance Coro::EV or Coro::Event modules, or will use a generic integration method that should work with any event loop supported by AnyEvent.



For performance reasons, it is recommended that the main program or something else run the event loop of the event model you use, i.e.

   use Gtk2; # <- the event model
   use AnyEvent;
   use Coro:

   # initialise stuff
   async { ... };

   # now run mainloop of Gtk2
   main Gtk2;

You can move the event loop into a thread as well, although this tends to get confusing:

   use Gtk2;
   use AnyEvent;
   use Coro:

   async { main Gtk2 };

   # do other things...
   while () {
      use Coro::AnyEvent;
      Coro::AnyEvent::sleep 1;
      print "ping...\n";

You can also do nothing, in which case Coro::AnyEvent will invoke the event loop as needed, which is less efficient, but sometimes very convenient.

What you MUST NOT EVER DO is to block inside an event loop callback. The reason is that most event loops are not reentrant and this can cause a deadlock at best and corrupt memory at worst.

Coro will try to catch you when you block in the event loop ("FATAL: $Coro::IDLE blocked itself"), but this is just best effort and only works when you do not run your own event loop.

To avoid this problem, start a new thread (e.g. with Coro::async_pool) or use Coro::unblock_sub to run blocking tasks.


If you need to wait for a single event, the rouse functions will come in handy (see the Coro manpage for details):

   # wait for single SIGINT
      my $int_w = AnyEvent->signal (signal => "INT", cb => Coro::rouse_cb);


Keep in mind that, as shipped, Coro and Coro::AnyEvent only work with AnyEvent, and only when AnyEvent is actually used (i.e. initialised), so this will not work:

   # does not work: EV without AnyEvent is not recognised
   use EV;
   use Coro;


And neither does this, unless you actually use AnyEvent for something:

   # does not work: AnyEvent must be initialised (e.g. by creating watchers)
   use EV;
   use AnyEvent;
   use Coro;


This does work, however, because you create a watcher (condvars work, too), thus forcing AnyEvent to initialise itself:

   # does work: AnyEvent is actually used
   use EV;
   use AnyEvent;
   use Coro;

   my $timer = AE::timer 1, 1, sub { };


And if you want to use AnyEvent just to bridge between Coro and your event model of choice, you can simply force it to initialise itself, like this:

   # does work: AnyEvent is initialised manually
   use POE;
   use AnyEvent;
   use Coro;

   AnyEvent::detect; # force AnyEvent to integrate Coro into POE


Coro::AnyEvent also offers a few functions that might be useful.


This call will block the current thread until the event loop has polled for potential new events and instructs the event loop to poll for new events once, without blocking.

Note that this call will not actually execute the poll, nor will it wait until there are some events, just block until the event loop has polled for new events, so other threads will have a chance to run.

This is useful when you have a thread that does some computations, but you still want to poll for new events from time to time. Simply call poll from time to time:

   my $long_calc = async {
      for (1..10000) {
         # do some stuff, make sure it takes at least 0.001s or so

Although you should also consider idle or idle_upto in such cases.

Coro::AnyEvent::sleep $seconds

This blocks the current thread for at least the given number of seconds.


This call is similar to poll in that it will also poll for events. Unlike poll, it will only resume the thread once there are no events to handle anymore, i.e. when the process is otherwise idle.

This is good for background threads that shouldn't use CPU time when foreground jobs are ready to run.

Coro::AnyEvent::idle_upto $seconds

Like idle, but with a maximum waiting time.

If your process is busy handling events, calling idle can mean that your thread will never be resumed. To avoid this, you can use idle_upto and specify a timeout, after which your thread will be resumed even if the process is completely busy.

Coro::AnyEvent::readable $fh_or_fileno[, $timeout]
Coro::AnyEvent::writable $fh_or_fileno[, $timeout]

Blocks the current thread until the given file handle (or file descriptor) becomes readable (or writable), or the given timeout has elapsed, whichever happens first. No timeout counts as infinite timeout.

Returns true when the file handle became ready, false when a timeout occurred.

Note that these functions are quite inefficient as compared to using a single watcher (they recreate watchers on every invocation) or compared to using Coro::Handle.

Note also that they only work for sources that have reasonable non-blocking behaviour (e.g. not files).

Example: wait until STDIN becomes readable, then quit the program.

   use Coro::AnyEvent;
   print "press enter to quit...\n";
   Coro::AnyEvent::readable *STDIN;
   exit 0;


Unfortunately, few event loops (basically only EV and Event) support the kind of integration required for smooth operations well, and consequently, AnyEvent cannot completely offer the functionality required by this module, so we need to improvise.

Here is what this module does when it has to work with other event loops:


AnyEvent, to see which event loops are supported, Coro::EV and Coro::Event for more efficient and more correct solutions (they will be used automatically if applicable).


   Marc A. Lehmann <>
syntax highlighting: