ꦫꦣꦺꦤ꧀ꦄꦤ꧀ꦠꦱꦺꦤ

PATH: usr / share / doc / perl-Thread-Queue / examples

#!/usr/bin/perl

# Simplified example illustrating event handling and callback threads

# Callback threads register their queues with the event handler thread.
# Events are passed to the event handler via a queue.
# The event handler then disseminates the event to the appropriately
#   registered thread.

use strict;
use warnings;

use threads;
use Thread::Queue;

MAIN:
{
    # Queue for registering callbacks
    my $regis_q = Thread::Queue->new();

# Queue for disseminating events
    my $event_q = Thread::Queue->new();

# Create callback threads
    threads->create('CallBack', 'USR1', $regis_q)->detach();
    threads->create('CallBack', 'USR2', $regis_q)->detach();
    threads->create('CallBack', 'HUP', $regis_q)->detach();
    threads->create('CallBack', 'ALRM', $regis_q)->detach();

# Create event handler thread
    threads->create('EventHandler', $regis_q, $event_q)->detach();

# Capture SIGUSR1 events
    $SIG{'USR1'} = sub {
        $event_q->enqueue('USR1');  # Send to event handler
    };

# Capture SIGUSR1 events
    $SIG{'USR2'} = sub {
        $event_q->enqueue('USR2');  # Send to event handler
    };

# Capture SIGHUP events
    $SIG{'HUP'} = sub {
        $event_q->enqueue('HUP');  # Send to event handler
    };

# Capture SIGHUP events
    $SIG{'ALRM'} = sub {
        $event_q->enqueue('ALRM');  # Send to event handler
        alarm(5);                   # Reset alarm
    };

# Ready
    print(<<_MSG_);
Send signals to PID = $$
  (e.g., 'kill -USR1 $$')
Use ^C (or 'kill -INT $$') to terminate
_MSG_

# Set initial alarm
    alarm(5);

# Just hang around
    while (1) {
        sleep(10);
    }
}

### Subroutines ###

sub EventHandler
{
    my ($regis_q, $event_q) = @_;

my %callbacks;   # Registered callback queues

while (1) {
        # Check for any registrations
        while (my ($event_type, $q) = $regis_q->dequeue_nb(2)) {
            if ($q) {
                $callbacks{$event_type} = $q;
            } else {
                warn("BUG: Bad callback registration for event type $event_type\n");
            }
        }

# Wait for event
        if (my $event = $event_q->dequeue()) {
            # Send event to appropriate queue
            if (exists($callbacks{$event})) {
                $callbacks{$event}->enqueue($event);
            } else {
                warn("WARNING: No callback for event type $event\n");
            }
        }
    }
}

sub CallBack
{
    my $event_type = shift;   # The type of event I'm handling
    my $regis_q    = shift;

# Announce registration
    my $tid = threads->tid();
    print("Callback thread $tid registering for $event_type events\n");

# Register my queue for my type of event
    my $q = Thread::Queue->new();
    $regis_q->enqueue($event_type, $q);

# Process loop
    while (1) {
        # Wait for event callback
        my $item = $q->dequeue();
        # Process event
        print("Callback thread $tid notified of $item event\n") if $item;
    }
}

# EOF

[-] queue.pl [edit]
[-] callback.pl [edit]
[+] ..