I tweaked some things, and completely replaced the client.

With the sleep in the client, you can see it runs $max at a time.

#!/usr/bin/perl

# http://perlmonks.org/?node_id=1211329

use strict;
use warnings;

if( @ARGV ) # if any argument, it's the server, otherwise the client
            # ( for testing purposes :)
  {
  ### tcp server

  use DBI;
  use IO::Socket::INET;

  ### flush after every write
  $|= 1;

    # creating object interface of IO::Socket::INET modules which inte
+rnally does
    # socket creation, binding and listening at the specified port add
+ress.
    my $socket = new IO::Socket::INET (
      LocalHost=> '127.0.0.1',
      LocalPort=> '5000',
      Proto=> 'tcp',
      Listen=> 5,
      Reuse=> 1
    ) or die "ERROR in Socket creation: $!\n";
    print "I am waiting clients to connect on port 5000.\n";

  ### infinite loop
  while(1) {
    my($client_socket);
    my($peeraddress, $peerport);
    my($row, $data);
    my @processes= ('one', 'two', 'three', 'four', 'five', 'six', 'sev
+en', 'eight', 'nine', 'ten');


    while($row= shift(@processes)) {
      $client_socket = $socket->accept();
      $peeraddress = $client_socket->peerhost();
      $peerport = $client_socket->peerport();
      print "Sending $row to $peeraddress:$peerport)... ";

      # write to the newly accepted client.
      print $client_socket "$row\n";

      # read from the newly accepted client.
      $data = <$client_socket> // 'nothing';
      chomp($data);
      print "got $data from client.\n";

      $client_socket->close();
    }
    #$socket->close();
  }
  }
else
  {
  ### tcp client
  
  my $max = 2;
  my $active = 0;

  while( 1 )
    {
    while( $active < $max )
      {
      if( my $pid = fork ) # parent
        {
        $active++;
        }
      elsif( defined $pid ) # child
        {
        my($socket, $data);
        $socket= new IO::Socket::INET (
          PeerHost=> '127.0.0.1',
          PeerPort=> '5000',
          Proto=> 'tcp'
        ) or die "ERROR in Socket creation: $!\n";

        $socket->autoflush(1);
        $data= <$socket>;
        chomp($data);
        $socket->close();
        print "($$) Got $data from producer.\n";
        sleep 1;
        exit;
        }
      else
        {
        die "fork failed $!";
        }
      }
    if( $active == $max )
      {
      wait;
      $active--;
      }
    }
  }
[download]

Note that the server was trying to read back from the client who never wrote anything ???

Thank you tybalt89, yes you were right... the code it is far from being working. TheMagician. PS. to all the wisdom keepers: This is a Proof of Concept; what I would like to demonstrate is the scalability you can get from having 1 producer (server) and more consumers (clients) that are taking "$messages" from the same tcp source. And what about if you can control that the number of processes running at the same time? These are the data I am going to collect in order to validate the POC effectiveness.

### tcp client

#!/usr/bin/env perl
use strict;
use warnings 'all';
$|= 1;

my $n= shift || 2;
my $active= 0;

sub getFromProducer {
  use IO::Socket::INET;

  my($socket, $data);
  $socket= new IO::Socket::INET (
    PeerHost=> '127.0.0.1',
    PeerPort=> '5000',
    Proto=> 'tcp'
  ) or die "ERROR in Socket creation: $!\n";
  $socket->autoflush(1);
  $data= <$socket>;
  chomp($data);
  print $socket "received\n";
  $socket->close();
  return $data;
}

print "Client started.\n";
while(my $data= &getFromProducer) {
  if($active<$n) {
    if(my $pid= fork) {
      $active++;
    } elsif(defined($pid)) {
      print ". Got $data.\n";
      select(undef, undef, undef, int(rand()*10)+1);
      exit
    } else {
      die "Cannot fork: $!\n";
    }
  }
  if($active==$n) {
    wait;
    $active--;
  }
}
print "Client finished.\n";

# vim: set nohls nowrap ts=2 sw=2 sts=2 et ft=perl:
[download]

PS. I have divided the client from the server, because in my PoC the clients are placed into a different host than the server.

Thanks for answering. 1. I have a queue of tasks, a socket is giving me; 2. I would like to process these tasks 'n' processes at a time; 3. Always 'n' processes should be active and running; 4. Until the end of the queue has been reached. I am thinking of a 'scalable' way and use more clients to process the tasks queue. TheMagician

Have you looked at Parallel::ForkManager?

Edit: changed title because "always 'n' processes" reads too much like "Guns 'n' Roses" or "fish 'n' chips" to me.

You should elaborate on your requirements. Is this intended to be portable? Windows/linux? Do you need it as perl code? There are utilities that can help in running parallel tasks (e.g. xargs). Do you need those jobs as separate processes; perhaps a threaded version might suit you as well?

Have you searched for modules (e.g. Parallel::ForkManager)? Do you actually need a robust, efficient solution or is this homework?