How about shuffle from List::Util?

use List::Util qw( shuffle );

open(my $fh, '<', '...')
or die("Unable to open input file: $!\n");

my @shuffed_array = shuffle <$fh>;
[download]

On the other hand, you probably want to spread entries from the same domain, not randomize the order of the array. I'm not sure how to do that.

What is the application? Often it helps us know how to advise you if we know what you are trying to achieve.

If the number of entries for each domain is the same then the code below will interleave them for you

use warnings;
use strict;

my %domains;

while (my $line = <DATA>)
  {
  chomp $line;
  my ($name, $domain) = split /@/, $line;
  
  $domains{$domain} = [] if ! defined $domains{$domain};
  push @{$domains{$domain}}, $line;
  }

while (%domains)
  {
  for my $domain (keys %domains)
    {
    print ((shift @{$domains{$domain}}) . "\n");
    delete $domains{$domain} if ! @{$domains{$domain}};
    }
  }
  
__DATA__
ads@domain.com
ads@domain.com
ads@domain1.com
ads@domain1.com
ads@domain2.com
ads@domain2.com
[download]

Prints:

ads@domain.com
ads@domain1.com
ads@domain2.com
ads@domain.com
ads@domain1.com
ads@domain2.com
[download]

I think the following will give you a very good spread. I concocted it from the top of my head, so I don't garantee results.

use strict;
use warnings;


open(my $fh, '<', '...')
or die("Unable to open input file: $!\n");


# Group domains into an AoA.
# Very efficient since the input fileis already sorted by domain.

my @grouped;

my $prev_domain = 'invalid domain';

while (<$fh>) {
   chomp;

   my $addr   = $_;
   my $domain = ...;

   if ($domain ne $prev_domain) {
      $prev_domain = $domain;
      unshift(@grouped, []);
   }

   push(@{$grouped[0]}, $addr);
}


# Sort groups by group size.
# Gives something like:
# @sorted = (
#    [ qw( g1             ) ],
#    [ qw( f1             ) ],
#    [ qw( e1             ) ],
#    [ qw( d1 d2          ) ],
#    [ qw( c1 c2 c3       ) ],
#    [ qw( b1 b2 b3       ) ],
#    [ qw( a1 a2 a3 a4 a5 ) ],
# );

my @sorted = sort { @$a <=> @$b } @grouped;


my @ordered;

my $prev_last = 0;
my $break     = 0;
my $offset    = 0;

for (;;) {
   my $p = shift(@sorted);

   last if not defined $p;

   my $last = $#$p;
   if ($last != $prev_last) {
      $prev_last = $last;
      $break     = @ordered / $last;
      $offset    = 0;
   }

   foreach my $i (reverse 0..$last) {
      splice(@ordered, $i*$break+$offset, 0, $p->[$i]);
   }

   $offset++;
}

{
   local $, = ", ";
   local $\ = "\n";
   print(@ordered);
}
[download]

or if you have unequal sized groups of domains then this may suit:

use warnings;
use strict;

my %domains;

while (my $line = <DATA>)
  {
  chomp $line;
  my ($name, $domain) = split /@/, $line;
  
  $domains{$domain} = [] if ! defined $domains{$domain};
  push @{$domains{$domain}}, $line;
  }

my @counts;
my $avg = 0;

for my $domain (keys %domains)
  {
  my $count = scalar @{$domains{$domain}};
  $avg += $count;
  push @counts, $count
  }

$avg /= @counts;

my @ballanced;

for my $domain (keys %domains)
  {
  my @names = @{$domains{$domain}};
  if (@names <= int $avg)
    {
    push @ballanced, [@names];
    next;
    }
    
  my $toIns = @names / int $avg;
  my $inc = int (@ballanced / $toIns);
  $inc = 1 if $inc < 1;
  my $index = 0;
  while (@names)
    {
    my @sublist = splice @names, 0, $avg;
    splice @ballanced, $index, 0, [@sublist];
    $index += $inc;
    }
  }

my $going = 1;
while ($going)
  {
  $going = 0;
  
  for my $addrs (@ballanced)
    {
    next if ! @$addrs;
    my $name = shift @$addrs;
    print "$name\n";
    $going = 1;
    }
  }
  
__DATA__
ads1@domain.com
ads2@domain.com
ads1@domain1.com
ads2@domain1.com
ads1@domain2.com
ads2@domain2.com
ads3@domain2.com
ads4@domain2.com
ads1@domain3.com
ads1@domain4.com
ads2@domain4.com
[download]

Prints:

ads1@domain2.com
ads1@domain4.com
ads3@domain2.com
ads1@domain.com
ads1@domain3.com
ads1@domain1.com
ads2@domain2.com
ads2@domain4.com
ads4@domain2.com
ads2@domain.com
ads2@domain1.com
[download]