Well, every thread has some overhead too:

use strict;
use warnings;
use threads;

my $str = 'x' x 32_000_000;

sub fork_wait {
    my $pid = fork;
    if ($pid) {
        wait;
    }
    else {
        exit 0;
    }
}

sub create_thread_join {
    threads->create( sub { } )->join;
}

use Benchmark qw( cmpthese );

cmpthese - 3,
  {
    Forks   => \&fork_wait,
    Threads => \&create_thread_join,
  };

__END__
          Rate Threads   Forks
Threads 27.7/s      --    -73%
Forks    103/s    272%      --
[download]

Even without this 32M string threads not win. This is Linux, perhaps on Windows you will get other result.

perhaps on Windows you will get other result.

On windows, those two pieces of code are all but identical (except the fork version leaks scalars). Hence, there is little difference between them. I'd be interested to see the results without the 32M scalar if you've a moment?

Without 32M scalar it outputs:

         Rate Threads   Forks
Threads 230/s      --     -0%
Forks   231/s      0%      --
[download]

Shouldn't he be using eval in that case?

To know what he should use would require knowing his needs, and I don't know them. eval offers far less protection than forking. eval catches exceptions. Forking catches exceptions, signals and faults. It also provide a fresh environment which clears leaks and corrupt structures.