You are trying to make an array of arrays, and this is not possible in perl.

When you hear of AoA, it is really an array of array references! So @tlist$tnum is not doing at all what you expected, use strict; use warnings; could have given you some hints about the problem.

I think this is more like what you were trying to achieve (not tested)

foreach $thread (keys %threads) {
    $tsub[$tnum] = $thread;    
    $tlist[$tnum] = $threads{$thread};
    $tsize[$tnum] = @{$tlist[$tnum]};
    $tnum++;
}

print "\n\nThe Thread Arrays\n\n";
for ($i=0;$i<$tnum ;$i++) {
    print "\n$tsub[$i], size=$tsize[$i], @{$tlist[$i]}";
}
[download]

Now @tlist is an array of reference, and it should work.

As a matter of style, I would write it in a slightly different fashion>

# Define the arrays as lexical vars. 
# So you are sure they are not conflicting with other vars in the prog
+ram
my @tsub;
my @tlist;
foreach $thread (keys %threads) {
    # using push you don't need the counter
    push(@tsub, $thread);
    push(@tlist, $threads{$thread}); 
}

print "\n\nThe Thread Arrays\n\n";
for ($i=0;$i<@tsub ;$i++) {
    # compute tsize only when you need it, another array is useless
    my $tsize=@{$tlist[$i]};
    print "\n$tsub[$i], size=$tsize, @{$tlist[$i]}";
}
[download]

It sounds like you want something like:

my @tsub  = keys %threads;
my @tlist = values %threads;
my @tsize = map scalar @$_, @tlist;

print "The Thread Arrays\n\n";
for my $i ( 0 .. $#tsub ) {
    print "$tsub[$i], size=$tsize[$i], @{$tlist[$i]}\n";
}
[download]

use Data::Dumper;
 
$copy=1; #what you want?
 
%threads=(
      keyA => [ 2, 6, 8 ],
      keyB => [ 3, 5, 10, 14, 18 ],
     );
 
$tnum=0;
foreach $thread (keys %threads) {
    $tsub[$tnum]      = $thread;    
    $tlist[$tnum]     = $threads{$thread}    unless $copy;
    @{$tlist[$tnum]}  = @{$threads{$thread}} if $copy;
    $tsize[$tnum]     = @{$tlist[$tnum]};    
    $tnum++;
}
 
print Dumper \@tsub,\@tlist,\@tsize;
[download]

# OUTPUT

there are more elegant ways using arrayslices but I think you should first start to understand perlref

UPDATE: Who cares, here a solution with slices (no copy)

@tsub2   = keys %threads;
@tlist2  = @threads{@tsub2};
@tsize2  = map { scalar @{$_} } @tlist2;
 
print Dumper \@tsub2,\@tlist2,\@tsize2;
[download]

hmmm that solution without slices is even simpler, I wasn't sure that the order of keys and values are guarantied, but it's documented so, as long as the hash isn't modified.

@tlist[$tnum] = @{$threadds{$thread};
[download]

Can you give an example of the input you have and the output you expect?

Ok, I think I see what you're trying to do.
1. walk through threads
2. each key in threads points to an array ref
3. store each arrayref into an array

modifying your code without munging it too much, I change to storing the array ref in $tlist[$tnum]; And then when we access from $tlist, we dereference into the array.

The syntax you had @tlist[$i] was actually doing an array slice.

print "\n\nThe Hash Table\n\n";
foreach $thread (keys %threads) {
    print "$thread: @{$threads{$thread}}\n";
}

#this prints out lines like:
#keyA: 2 6 8
#keyB: 3 5 10 14 18
#etc.

# Convert hash table into arrays for Threads, with common index $tnum

$tnum=0;
foreach $thread (keys %threads) {
    $tsub[$tnum] = $thread;    
    $tlist[$tnum] = $threads{$thread}; #store the array reference. 
    $tsize[$tnum] = @{ $tlist[$tnum] };    
    $tnum++;
}

print "\n\nThe Thread Arrays\n\n";
for ($i=0;$i<$tnum ;$i++) {
    print "\n$tsub[$i], size=$tsize[$i], @{$tlist[$i]";
}
[download]

You might also find perldsc useful.