Here is my suggestion:

...clipped... (not applicable)
#I was computing the intersection and not the union.
[download]

of course you will need to alter $list_count depending on how many arrays you are using.

Update! Perhaps I should have read the replies in more depth since I apparently didnt understand the OP question.
In which case my suggestion would follow those already presented... in short:

my @unique = do{
        my %seen;
        undef @seen{@list1, @list2, @list3};
        sort keys %seen;};
[download]

here is the original node with benchmarks for this.

Update! This got me thinking and here is what I humbly offer to the community at large.

package ListMerger;
use strict;

sub new
{
    my $pkg = shift;
    my $self;
    return bless \$self, $pkg;
}
#call with references to lists as arguments
#ex: @union = $obj->union(\@list1,\@list2,\@list3);
sub union
{
    my $self = shift;
    my @lists = map{@{$_}}@_;
    return do{
        my %seen;
        undef @seen{@lists};
        sort keys %seen;
    };
}
#call with references to lists as arguments
sub intersection
{
    my $self = shift;
    my @lists = map{@{$_}}@_;
    my $list_count = scalar(@_);
    return do{my %seen;
            $seen{$_}++ for(@lists);
            map{delete $seen{$_} if($seen{$_}<$list_count)}keys %seen;
            sort keys %seen;
        };
}
#call with references to lists as arguments
sub exclusion
{
    my $self = shift;
    my @lists = map{@{$_}}@_;
    my $list_count = scalar(@_);
    return do{my %seen;
            $seen{$_}++ for(@lists);
            map{delete $seen{$_} if($seen{$_} == $list_count)}keys %se
+en;
            sort keys %seen;
        };
}
#call with references to list as arguments
sub shared
{
    my $self = shift;
    my @lists = map{@{$_}}@_;
    return do{my %seen;
        $seen{$_}++ for(@lists);
        map{delete $seen{$_} if($seen{$_} == 1)}keys %seen;
        sort keys %seen;
    };
}
1;
[download]