Yes. I've been using and describing these techniques here for a 3 years or more, but I am looking for a way to ecapsulate the messy and fiddly business of shared data, access control and the process of spawning 'clean&light' threads into a module with simple interface. I gotten close a couple of times, but there is always something that I haven't found a good way to do

Your example code misses the point. In a nutshell, the problem is

• how to pass a coderef + parameters + context to a pre-existing dormant thread. And how to return the thread handle from that thread to the calling code for joining and results retrieval.

  Possible interface:

  use threads::lite;
  
  my @threads = threads::lite->spawn( 10 );
  
  ...
  
  ## Then when I know what I want a thread to do
  my $Xthread = pop threads;
  $Xthread->run( \&doX, @Xargs );
  
  ....
  
  my @Xresults = $Xthread->join;
  [download]

• Or: How to start a thread factory thread early so that you have a clean thread and then later pass a coderef + parameters + context to that factory thread; have it spawn a new (clean) thread; and then return the handle from the new thread to the caller for subsequent joining and results retrieval.

  Possible interface:

  use threads::lite;
  my $threadFactory = threads::lite->genFactory;
  
  ....
  
  my( $Xthread ) = $threadsFactory->create( \&doX, @Xargs );
  my( $Ythread ) = $threadsFactory->create( \&doY, @Yargs );
  [download]

Don't take any notice of the module/method names shown. I could care less whether they are camelCase() or hugely_verbose_with_under_scores()--though I have my preferences like others, and I'd prefer that they weren't Hugely_Verbose_With_Camel_Case_And_Underscores() as I've encountered occasionally.

The crux of the matter is how to create light threads (which means early), but use them when I need them; and without having to reinvent the wheel of queues and synchronisation and all that good stuff in every program; and without cloning everything in my current thread into every thread I spawn.

Ie. A simple interface to lightweight, 'only-clone-what-is-needed' threads.