Perhaps a hash, or an array is would suit your purpose better. Here is an example using an array, also showing a way to put the vals in $i, $j, $k and a way to use a hash.

Update: Added hash demo to code too, and better behaviour when it runs out of values

use strict;
use warnings;

my @names;
while (my $name = <DATA>) {
    chomp $name;  # remove newline
    push @names, $name;
}
print "The third name is $names[2]\n";

my @copy = @names; # take a copy for the hash demo 

my ($i, $j, $k);
while (@names) {
    for (\$i, \$j, \$k) {
        if (@names) {
            $$_ = shift @names;
        }
        else {
            $$_ = 'ran out of records'; # could use undef too
        }
    }
    print "i: $i j:$j k: $k \n";
}

# and with a hash
my %hash;
while (@copy) {
    %hash = (i=>'', j=>'', k=>''); # clear the hash
    for my $key (qw(i j k)) {
        $hash{$key} = shift @copy if @copy;
    }
    print "the hash contains $hash{$_} under $_\n" for ('i'..'k');
}

__DATA__
a
b
c
d
e
f
g
h
[download]

Cheers,
R.

while ( my $a =<DATA> ){
  my $b=<DATA>;
  my $c=<DATA>;
  print $a;
}

# while ( my $a =<DATA>, my $b=<DATA>, my $c=<DATA> ){
#   print $a;
# }
  
__DATA__
a
b
c
d
e
f
g
h
[download]

please note the difference, the second version will stop after printing "d", since the last group has only 2 entries (i.e. $c is undef)

This code builds an AoA by processing three lines at a time and pushing an anonymous array of chomped lines for each group.

$ perl -Mstrict -Mwarnings -MData::Dumper -e '
sub groupsOf (&$@);

open my $inFH, q{<}, \ <<EOD or die $!;
a
b
c
d
e
f
g
h
EOD

my @arr;
push @arr, groupsOf { chomp @_; [ @_ ] } 3, <$inFH>;

sub groupsOf (&$@)
{
    my $rcToRun  = shift;
    my $groupsOf = shift;

    my $rcDoIt;
    $rcDoIt = sub
       {
           $rcToRun->(
              map shift, 1 .. ( @_ < $groupsOf ? @_ : $groupsOf )
              ),
           @_ ? &$rcDoIt : ();
       };

    &$rcDoIt;
}

print Data::Dumper->Dumpxs( [ \ @arr ], [ qw{ *arr } ] );'
@arr = (
         [
           'a',
           'b',
           'c'
         ],
         [
           'd',
           'e',
           'f'
         ],
         [
           'g',
           'h'
         ]
       );
$
[download]

I hope this is of interest.

Update: Simpler and assigns to three variables rather than constructing an AoA.

$ perl -Mstrict -Mwarnings -E '
> open my $inFH, q{<}, \ <<EOD or die $!;
> a
> b
> c
> d
> e
> f
> g
> h
> EOD
> 
> while ( not eof $inFH )
> {
>     my( $i, $j, $k ) =
>        map { chomp; $_ }
>        map { eof $inFH ? () : scalar <$inFH> }
>        1 .. 3;
>     say
>        q{$i - }, defined $i ? qq{$i; } : q{undef; },
>        q{$j - }, defined $j ? qq{$j; } : q{undef; },
>        q{$k - }, defined $k ? $k : q{undef};
> }'
$i - a; $j - b; $k - c
$i - d; $j - e; $k - f
$i - g; $j - h; $k - undef
$
[download]

for $x (f .. j){
chomp(${$x} = <DATA>);
}

print "$f $g $h $i $j\n";

__DATA__
a
b
c
d
e
[download]

do{for $x (i, g, k){
chomp(${$x} = <DATA>);
} print "$i $g $k\n";} until eof;

__DATA__
a
b
c
d
e
f
g
h
[download]

a b c
d e f
g h
[download]

> I think other monks won't approve, still:

Don't you think, you should at least mention no strict 'refs' ? :)

Cheers Rolf

( addicted to the Perl Programming Language)

yes, sorry
just couldn't restrain myself :)
I hope the readers will understand

• seek() to a position, relative to end-of-file, that you are quite sure is long enough to fit. ...
• Read a string starting from that position.
• Use a regex anchored at end-of-string to carve off the last three digits, e.g. /(\d+)\n(\d+)\n(\d+)$/ this assuming there are no whitespaces.
• The numbers you want are $1, $2, $3. (If they aren't, then die() because your assumption about "what you are quite sure is long enough" wasn't.)

Here's another way to do it:

#!/usr/bin/env perl -l

use strict;
use warnings;

my @values;

while (<DATA>) {
    chomp;
    push @values, $_;

    if (@values == 3) {
        process_values(@values);
        @values = ();
    } 
}

process_values(@values) if @values;

sub process_values {
    my ($i, $j, $k) = @_;
    print '$i = ', defined $i ? $i : '<undefined>';
    print '$j = ', defined $j ? $j : '<undefined>';
    print '$k = ', defined $k ? $k : '<undefined>';
}

__DATA__
a
b
c
d
e
f
g
h
[download]

Output:

$i = a
$j = b
$k = c
$i = d
$j = e
$k = f
$i = g
$j = h
$k = <undefined>
[download]

use strict; use warnings;
my @foo = ();
while (<DATA>){ chomp;
   if ($. < 4){push @foo, $_}}

print "my first variable is $foo[0]"; 
print "my second variable is $foo[1]";
print "my third variable is $foo[2]";

__DATA__
one
two
a beautiful tree, maybe an oak?
[download]

no need to read after "n lines"

And you can add also a fifth line to rename your variables and that's all:

while(@names) {
    my ($i, $j, $k)  = splice (@names, 0, 3);
    printf('$i is %s, $j is %s, $k is %s', $i, $j, $k);
    print "\n";
}
[download]