承诺不并行运行

Question

I am trying to use the Promises module to run a process in parallel. My requirement is not forking a new process and let it run.

I tried this code but it is not executing in parallel

use AnyEvent::HTTP;
use JSON::XS qw[ decode_json ];
use Promises qw[ collect deferred ];
use Data::Dumper;

sub process {
    my ($data) = @_;
    my $d = deferred;

    for (1..5) {
        print "\n$data " . $_ * $data;
    }

    $d->resolve($data);

    $d->promise;
}


collect(
    process(10),
    process(20),
    process(30),
)->then(
    sub {
        print Dumper(\@_);
    },
);

1;

The output is

10 10
10 20
10 30
10 40
10 50
20 20
20 40
20 60
20 80
20 100
30 30
30 60
30 90
30 120
30 150$VAR1 = [
          [
            10
          ],
          [
            20
          ],
          [
            30
          ]
        ];

What is wrong with this?

Answer 1

Promises are a mechanism to structure callbacks , not a way to run code in parallel . There is some connection between callbacks and parallelism because both can be used for asynchronous programming , where we run another piece of code if we have to wait for something. Without threads, requires that you use some event loop , and also tell the event loop when you are waiting.

Common Perl event loops are IO::Async , and Mojo::IOLoop from the Mojolicious web framework.

Perl doesn't really do multithreading – the threads are effectively a fork() emulation (see the threads warning ), and definitively not the kind of threads you know from Java.

Answer 2

It looks like you've taken the synopsis code from Promises and removed the event loop module AnyEvent::HTTP and all calls to it. That is why your program doesn't work as you expect

Promises can't supply parallelism on its own: it needs an event loop to create multiple processes that can run "in parallel", but any event loop module on CPAN will do fine

What is it that you want to use parallelism for? The right choice of event loop module will make all the difference

But don't forget that, unless your program's activity is disk-bound or network-bound, you are unlikely to see a major improvement in performance. Multi-processing is an illusion whereby the operating system will distribute processor time amongst processes, but with only a single processor the elapsed time will always be rather more than the equivalent process run in isolation

Answer 3

If you want an alternative approach that allows for parallel execution, using fork-based promise, there is also Promise::Me . With this, you could easily do something like:

my $p = Promise::Me->new(sub
{
    # Some code to execute
})->then(sub
{
    my( $resolve, $reject ) = @$_;
    my $res = shift( @_ ); # return value from the code executed above
    # more processing...
    # You can use $resolve->( $some_data ); to resolve or $reject->( $some_exception ); to reject.
})->then(sub
{
    my $more = shift( @_ ); # return value from the previous then
    # more processing...
})->catch(sub
{
    my $exception = shift( @_ ); # error that occured is caught here
})->finally(sub
{
    # final processing
})->then(sub
{
    # A last then may be added after finally
};

Each promise would be executed asynchronously and independently of the others.

As a full disclosure, I am the author of Promise::Me .