很多时候使用perl多线程可以达到很不错的效果，可以节约很多时间完成很复杂的工作。但通过perl threads模块的描述文件可以看到，它也有很多缺点。比如说在使用perl多线程的时候，必须的保证所有引用的模块都是支持thread。而在实际应用中，我们很难做到这样。比如我们要多线程，但同时要应用OLE模块去操作activex。 此用例应该是一种很常见的用例。那是不是意味着此时我们不得不放弃使用多线程呢。 非也， 本文介绍一种可以使用多线程和ole的例子。

 在官方网站上对这种情况给出的方案是：

If the module will only be used inside a thread, you can try loading the module from inside the thread entry point function using require (and import if needed):

sub thr_func{require Unsafe::Module# Unsafe::Module->import(...);....}

      If the module is needed inside the main thread, try modifying your application so that the module is loaded (again using require and ->import()) after any threads are started, and in such a way that no other threads are started afterwards。

再次，主要讨论一下第二种情况，既主要是该非thread模块放到方法中引用。下面是一个demo。

 

use threads;

use threads::shared;

use Thread::Queue;

no warnings 'threads';

# Time out const

my $TIMEOUT : shared;

$TIMEOUT = 1;

# the sig for end thread 

my $TERM : shared;

$TERM = 0;

#my $excel;

$SIG{

'INT'} = $SIG{

'TERM'} = sub{ print("\n>>> Terminating <<<\n"); $TERM=1;};

$SIG{

'KILL'} = sub{ printf("%3d <- Killed\n", threads->tid()); 

                    threads->detach() if !threads->is_detached();

                    threads->exit(); };

sub ThreadWatcher

{

    my $queue = shift;

    my %timers;

    

    while(!$TERM)

    {

        #print "ThreadWatcher -- TERM : $TERM\n";

        while(my $tid = $queue->dequeue_nb())

        {

            if (! defined($timers{$tid}{

'timeout'} = $queue->dequeue()) ||

                ! defined($timers{$tid}{

'thread'}  = threads->object($tid)))

            {

                # No timeout - unregister thread

                delete($timers{$tid});

            }

        }

               

        

        foreach my $tid (keys(%timers))

        {

            #print "$timers{$tid}{'thread'} \n";

            if(--$timers{$tid}{

'timeout'} < 0)

            {

                print "thread $timers{$tid}{'thread'} will be killed.\n";

                $timers{$tid}{

'thread'}->kill('KILL');

                delete($timers{$tid});

            }

        }

        

        # tick tock

        sleep(1);

    }

}

sub Worker

{

    #eval {use Win32::OLE::Variant;};

    

    my ($queue, $dataqueue) = @_;

    # get the thread id and register with watch

    my $tid = threads->tid();

    printf("Working -> %3d\n", $tid);

    $queue->enqueue($tid, $TIMEOUT);

    print "Worker -- TERM : $TERM\n";

    while(!$TERM)

    {

        

        #my $App = $dataqueue->dequeue();

        my $data = $dataqueue->dequeue();

        #deal with the data

        #print "Worker -- DATA : $App\n";

        print "Worker -- DATA : $data\n";

        

        #my $var = Win32::OLE::Variant->new(VT_BSTR, $data);

        #print "Worker VAR: $var\n";

    }

    

    # Remove signal handler

    $SIG{

'KILL'} = sub {};

    # Unregister with timer thread

    $queue->enqueue($tid, undef);

    # Tell user we're done

    printf("%3d <- Finished\n", $tid);

   

    threads->detach() if ! threads->is_detached();

    threads->exit();

}

# create time thread

my $watchQueue = Thread::Queue->new();

threads->create('ThreadWatcher', $watchQueue)->detach();

# create work thread

my $dataQueue = Thread::Queue->new();

threads->create('Worker', $watchQueue, $dataQueue);

NoneSafeModelScript('C:\Joe_Chen\Perl_Projects\Threads\update.xlsx');

WairLongTime(10);

sub WairLongTime

{

    my $temp = $_[0];

    $temp = $temp * 10000000;

    for(my $index = 0; $index < $temp; $index++)

    {

        $index * $index;

    }

    return $index;

}

sub NoneSafeModelScript

{

    eval 'use Win32::OLE';  

    eval 'use Win32::OLE::Variant';

    

    my $excel;

    for(my $index = 0; $index < 600; $index++)

    {

        print "Getting the Excel ActiveObject. Try # $index \n";

        WairLongTime(1);

        eval

        {

            $excel = Win32::OLE->GetActiveObject('Excel.Application') || Win32::OLE->new('Excel.Application', 'Quit');

        };

        if($@ or $excel == undef)

        {

            print "Unsuccessful: $@ \n";

            if($index == 599)

            {

                print "ERROR:Don\'t got the Excel Application";

            }

        }

        else

        {

            last;

        }

    }

    

    my $path = $_[0];

    

    my $book = $excel->workbooks->open($path);

    my $sheet = $book->worksheets(1);

    

    my $values = $sheet->Range("A1:D5")->{Value};

    my $row_counts = $sheet->Range("A1:C3")->{Rows}->{Count};

    my $column_counts = $sheet->Range("A1:C3")->{Columns}->{Count};

        

    print "NoneSafeModelScript : $row_counts \n";

    print "NoneSafeModelScript : $column_counts \n";

    

    for(my $row=1; $row<$row_counts + 1; $row++)

    {

        my $array_ref = $sheet->Cells($row,1)->{Value};

        print "NoneSafeModelScript : $array_ref \n";

        

        my $var = Variant(Win32::OLE::Variant->VT_BSTR, $array_ref);

        my $v = ref($var);

        #my $v = $var->Type();

        print "NoneSafeModelScript VAR: $var\n";

        print "NoneSafeModelScript VAR: $v\n";

        #$dataQueue->enqueue($var);

        $dataQueue->enqueue($array_ref);

        WairLongTime(2);

    }

    

    my $v = Variant(VT_DATE, "April 1 99");

    print $v->Type, "\n";

    print $v->Date(DATE_LONGDATE), "\n";

    print $v->Date("ddd',' MMM dd yy"), "\n";

    

    print Win32::OLE::Variant->VT_BSTR , "\n";

    

    $book->Close;

    $excel->Quit;

}

sub Wrap

{

    my $value = $_[0];

    my $var = Variant(VT_DATE, 'Jan 1,1970');

    print "Wrap : $var \n"; 

    return $var;

}

 

在此例子中，用到了queue，它的作用是将非thread 安全的数据通过管道传输，这样能避免他们互相调用。