A reference to the array is stored in the global (package) variable $array_ref (which itself doesn't go out of scope).  This increments the reference count of @array, so the array doesn't "vaporize" even though it is scoped lexically to the routine.

You can use Devel::Peek to investigate the reference counts.  When you add

    Dump $array_ref;
[download]

at the end of A(), and within B(), you'll see that the REFCNT is 2 within A(), but 1 within B()

# Dump from within A()
...
  SV = PVAV(0x138f058) at 0x13b4be0
    REFCNT = 2
...

# Dump from within B()
...
  SV = PVAV(0x138f058) at 0x13b4be0
    REFCNT = 1
...
[download]

This is because when @array leaves its scope, the REFCNT is decremented.  If there was no reference kept to it, the REFCNT would go down to zero here, and the variable would be freed.  But due to the reference, this doesn't happen.

sub a_sub {
    my @array = qw /a b c d e f g/;
    $ref = \@array;
}

a_sub();

print "$ref - @$ref - @array";
[download]

ARRAY(0x9dbb04) - a b c d e f g - 

Global symbol "$array_ref" requires explicit package name
[download]

"my" allocates a new variable, so what you're doing is completely safe.

(Optimisations normally cause the variable to be reused, but they are specifically disabled when a reference escapes the scope like here.)

Well, the needless use of a global variable probably isn't that safe. Return the reference instead.

use strict;    # Always!
use warnings;  # Always!

B(A());

sub A {
    my @array = qw(value_1 value_2);
    return \@array;
}

sub B {
    my ($array_ref) = @_;
    foreach my $i ( @{$array_ref} ) {
        print "Array Value: $i \n";
    }
}
[download]

See also Tutorials: Variable Scoping in Perl: the basics, Coping with Scoping )

use Devel::Peek qw(SvREFCNT);

my $a = 9;                   # 1 = $a is an SV of an IV with refcnt of
+ 1
warn SvREFCNT($a), "\n";

my $b = \$a;                 # 2 = (anonymous) scalar ref maintained b
+y $b
warn SvREFCNT($a), "\n";

my $d = my $c = $b;          # 4 = two more ref copies made
warn SvREFCNT($a), "\n";

my $f = my $e = \$b;         # 4 = $a unaffected by references _to_ $b
warn SvREFCNT($a), "\n";

my $g = [ $a ];              # 4 = copy of value  $a in array
warn SvREFCNT($a), "\n";

my $h = [ $c ];              # 5 = copy of ref to $a in array
warn SvREFCNT($a), "\n";

my $i = sub { $b, $c, $e };  # 5 = $a unaffected by closure over _refs
+_ to $a
warn SvREFCNT($a), "\n";

my $j = sub { $a, $a, $a };  # 6 = closure over actual lexical $a
warn SvREFCNT($a), "\n";

undef $_ for $b, $c, $d, $h, $j;  # 1 = kill all refcnt contributors (
+except for $a itelf)
warn SvREFCNT($a), "\n";
[download]