Perl doesn't use garbage collection per se, but rather reference counting.

Which basically means that memory is handed back to the memory pool, once it is no longer referenced. Automatically.

In this snippet:

sub fred {
    my( $x, $y ) = @_;
    my $result = $x * $y;
    return $result;
}
[download]

When the sub returns, none of the variables inside it can be referenced from anywhere else, so their reference counts are zero, and their memory will be returned to the pool, as the subroutine ends.

In this snippet:

sub genList {
    my( $start, $end, $step ) = @_;
    my @list;
    for( my $i=$start; $i < $end; $i += $step } push @list, $i;
    return \@list;
}
...
if( ???  ) { 
    my $arrayRef = getList( 10, 99, 3 );

    ## use list
}
[download]

The contents of array @list persists beyond the life of genList(), because the array is returned by reference; thus its reference count has been incremented, and is non-zero when genList() ends.

However, when the calling if block ends, that reference count will be decremented, and as it will drop to zero, the memory will be freed back to pool.

Bottom line: for the most part, Perl programmer's do not worry about, or suffer from, memory leaks. Nor does their code suffer those awful pregnant pauses whilst the garbage collector goes off searching through memory trying to find and clean up no longer used space. Memory is reclaimed automatically, on the fly, as soon as it is no longer needed.

It is possible to create memory leaks, by creating self-referencing structures, but you have to work hard to do it, and there are techniques -- weakening -- to deal with it if, the self-referential data is a deliberate need, rather than accidental. In 15 years of daily Perl, including a lot of very heavy data processing, I've never needed to use weakening.

Hi Svetlana,

Do perl programmers have to worry like C++ programmers do?

In general, no. The main thing to remember is that circular references will prevent garbage collection. Other than that, Perl programmers don't usually have to worry about memory management, exceptions may be when trying to fit large amounts of data into RAM, or when writing XS code.

I think you'll find the replies in this thread very informative: Do subroutine variables get destroyed?

Hope this helps,
-- Hauke D

Note that a reference-counted garbage collector, as used by Perl, has both advantages and disadvantages compared to a tracing garbage collector, as used by Java. For more details, see: Re^2: Do subroutine variables get destroyed? (Deterministic Destructor References)

Perl's uses reference counting as its method of doing garbage collection. As soon as the last reference to a value is released, the value is destroyed and freed. This has both advantages and disadvantages over Java's approach.

A disadvantage over Java's method is that you have to worry about circular references which will cause a leak.

push @{ $parent->{children} }, $child;
weaken( $child->{parent} = $parent );   # Needed to avoid memory leak.
[download]

An advantage over Java's method is that you don't have to worry about when the object is destroyed, as it will be destroyed the moment is ceases being referenced. This avoids subtle, intermittent, timing-dependent errors.

{
   Resource res = get_resource_exclusively(res_id);
   // ...
   res.release();  // Needed or the next line might fail.
}

{
   Resource res = get_resource_exclusively(res_id);
   // ...
   res.release();
}
[download]

You might even need a try/catch block to ensure timely destruction in some places.

Resource res = get_resource_exclusively(res_id);
try {
   // ...
}
catch (Exception e) {
   res.release();
   throw e;
}
[download]

The GC of Perl does very good work, it collects all variables that it is supposed to :) But each GC has its limitations. Otherwise, there would be no need in things like "weak references". They are available in Java, C#, Perl and few other languages.

Creating memory leak in Java is very easy. Just add event listener while building GUI, and then discard it without unregistering. GC is convenient, but it does not mean, that programmer should not think about memory management. That thing is unavoidable. So, just like in any other programming language, one has to know about peculiarities of GC in Perl, and then manage memory appropriately.

On a side note, I believe C is the best language for development. Simply because it does not pretend, that one should not worry about memory management :)