perldoc > srand(42)

    srand EXPR
    srand   Sets and returns the random number seed for the "rand" operator.

            The point of the function is to "seed" the "rand" function so
            that "rand" can produce a different sequence each time you run
            your program. When called with a parameter, "srand" uses that
            for the seed; otherwise it (semi-)randomly chooses a seed (see
            below). In either case, starting with Perl 5.14, it returns the
            seed. To signal that your code will work *only* on Perls of a
            recent vintage:

                use v5.14;  # so srand returns the seed

            If "srand" is not called explicitly, it is called implicitly
            without a parameter at the first use of the "rand" operator.
            However, there are a few situations where programs are likely to
            want to call "srand". One is for generating predictable results,
            generally for testing or debugging. There, you use srand($seed),
            with the same $seed each time. Another case is that you may want
            to call "srand" after a "fork" to avoid child processes sharing
            the same seed value as the parent (and consequently each other).

            Do not call srand() (i.e., without an argument) more than once
            per process. The internal state of the random number generator
            should contain more entropy than can be provided by any seed, so
            calling "srand" again actually *loses* randomness.

            Most implementations of "srand" take an integer and will
            silently truncate decimal numbers. This means srand(42) will
            usually produce the same results as srand(42.1). To be safe,
            always pass "srand" an integer.

            A typical use of the returned seed is for a test program which
            has too many combinations to test comprehensively in the time
            available to it each run. It can test a random subset each time,
            and should there be a failure, log the seed used for that run so
            that it can later be used to reproduce the same results.

            If the "PERL_RAND_SEED" environment variable is set to a
            non-negative integer during process startup then calls to
            srand() with no arguments will initialize the perl random number
            generator with a consistent seed each time it is called, whether
            called explicitly with no arguments or implicitly via use of
            rand(). The exact seeding that a given "PERL_RAND_SEED" will
            produce is deliberately unspecified, but using different values
            for "PERL_RAND_SEED" should produce different results. This is
            intended for debugging and performance analysis and is only
            guaranteed to produce consistent results between invocations of
            the same perl executable running the same code when all other
            factors are equal. The environment variable is read only once
            during process startup, and changing it during the program flow
            will not affect the currently running process. See perlrun for
            more details.

            "rand" is not cryptographically secure. You should not rely on
            it in security-sensitive situations. As of this writing, a
            number of third-party CPAN modules offer random number
            generators intended by their authors to be cryptographically
            secure, including: Data::Entropy, Crypt::Random,
            Math::Random::Secure, and Math::TrulyRandom.