Perl Queue和Threads异常退出

时间:2013-08-21 08:10:38

标签: multithreading perl

我对Perl很新,尤其是Perl Threads。 我想完成:

  1. 有5个线程将​​数据(随机数)排入a Thread :: queue
  2. 有3个线程可以从中取消数据 螺纹::队列。
  3. 我为完成上述任务而编写的完整代码:

    #!/usr/bin/perl -w
    use strict;
    use threads;
    use Thread::Queue;
    
    
    my $queue = new Thread::Queue();
    our @Enquing_threads;
    our @Dequeuing_threads;
    
    sub buildQueue
    {
        my $TotalEntry=1000;
        while($TotalEntry-- >0)
        {
            my $query = rand(10000);
            $queue->enqueue($query);
            print "Enque thread with TID " .threads->tid . " got $query,";
            print "Queue Size: " . $queue->pending . "\n";
        }
    }
    sub process_Queue 
    {
        my $query;
        while ($query = $queue->dequeue) 
        {
            print "Dequeu thread with TID " .threads->tid . " got $query\n";
        }
    }
    push @Enquing_threads,threads->create(\&buildQueue) for 1..5;
    push @Dequeuing_threads,threads->create(\&process_Queue) for 1..3;
    

    我正面临的问题

    • 线程未按预期同时运行。
    • 整个程序异常退出以下控制台输出:
      

    Perl退出活动线程:           8运行和未加入

        0 finished and unjoined
        0 running and detached
    
        Enque thread with TID 5 got 6646.13585023883,Queue Size: 595 
        Enque thread with TID 1 got 3573.84104215917,Queue Size: 595
    

    感谢任何有关代码优化的帮助。

1 个答案:

答案 0 :(得分:4)

这种行为是可以预期的:当主线程退出时,所有其他线程也会退出。如果你不在乎,你可以$thread->detach他们。否则,您必须手动$thread->join他们,我们会这样做。

$thread->join等待线程完成,并获取返回值(线程可以像子例程一样返回值,尽管上下文(list / void / scalar)必须在生成时修复)。 / p>

我们将detach排队数据的线程:

threads->create(\&buildQueue)->detach for 1..5;

现在对于出列线程,我们将它们放入词法变量(为什么你使用全局变量?),以便我们以后可以将它们出列:

my @dequeue_threads = map threads->create(\&process_queue), 1 .. 3;

然后等待他们完成:

$_->join for @dequeue_threads;

我们知道分离的线程将在程序退出之前完成执行,因为出队线程退出的唯一方法是耗尽队列。

除了一个半的​​错误。您看,空队列和已完成队列之间存在差异。如果队列只是空的,则出列线程将在$queue->dequeue上阻塞,直到它们获得一些输入。传统的解决方案是dequeue,而他们获得的价值是定义的。我们可以通过在队列中提供尽可能多的undef值来打破循环,因为有从队列中读取的线程。更新的Thread::Queue版现有end方法,可让dequeue为所有后续调用返回undef

当结束队列时,问题是。我们应该在所有排队线程退出后继续这样做。这意味着,我们应该手动等待它们。叹息。

my @enqueueing = map threads->create(\&enqueue), 1..5;
my @dequeueing = map threads->create(\&dequeue), 1..3;
$_->join for @enqueueing;
$queue->enqueue(undef) for 1..3;
$_->join for @dequeueing;

sub dequeuingwhile(defined( my $item = $queue->dequeue )) { ... }

使用defined测试修复了另一个错误:rand可以返回零,虽然这不太可能,并且会在大多数测试中失败。 rand的约定是它返回一个伪随机浮点数,包括零和排除某个上限之间:来自区间[0, x)的数字。绑定默认为1

如果您不想手动加入排队线程,可以使用信号量来表示completition。信号量是一种多线程原语,可以递增和递减,但不能低于零。如果递减操作会使丢弃计数低于零,则调用将阻塞,直到另一个线程引发计数。如果起始计数为1,则可以将其用作阻止资源的标志。

我们也可以从负值1 - $NUM_THREADS开始,让每个线程递增值,这样只有当所有线程都退出时,它才能再次递减。

use threads;  # make a habit of importing `threads` as the first thing

use strict; use warnings;
use feature 'say';

use Thread::Queue;
use Thread::Semaphore;

use constant {
  NUM_ENQUEUE_THREADS => 5,  # it's good to fix the thread counts early
  NUM_DEQUEUE_THREADS => 3,
};

sub enqueue {
  my ($out_queue, $finished_semaphore) = @_;
  my $tid = threads->tid;

  # iterate over ranges instead of using the while($maxval --> 0) idiom
  for (1 .. 1000) {
    $out_queue->enqueue(my $val = rand 10_000);
    say "Thread $tid enqueued $val";
  }

  $finished_semaphore->up;
  # try a non-blocking decrement. Returns true only for the last thread exiting.
  if ($finished_semaphore->down_nb) {
    $out_queue->end;  # for sufficiently modern versions of Thread::Queue
    # $out_queue->enqueue(undef) for 1 .. NUM_DEQUEUE_THREADS;
  }
}

sub dequeue {
  my ($in_queue) = @_;
  my $tid = threads->tid;
  while(defined( my $item = $in_queue->dequeue )) {
    say "thread $tid dequeued $item";
  }
}

# create the queue and the semaphore
my $queue = Thread::Queue->new;
my $enqueuers_ended_semaphore = Thread::Semaphore->new(1 - NUM_ENQUEUE_THREADS);

# kick off the enqueueing threads -- they handle themself
threads->create(\&enqueue, $queue, $enqueuers_ended_semaphore)->detach for 1..NUM_ENQUEUE_THREADS;

# start and join the dequeuing threads
my @dequeuers = map threads->create(\&dequeue, $queue), 1 .. NUM_DEQUEUE_THREADS;
$_->join for @dequeuers;

如果线程似乎不是并行运行,而是顺序运行,请不要惊讶:此任务(排队随机数)非常快,并且不适合多线程(排队比创建随机更昂贵数)。

以下是一个示例运行,其中每个enqueuer只创建两个值:

Thread 1 enqueued 6.39390993005694
Thread 1 enqueued 0.337993319585337
Thread 2 enqueued 4.34504733960242
Thread 2 enqueued 2.89158054485114
Thread 3 enqueued 9.4947585773571
Thread 3 enqueued 3.17079715055542
Thread 4 enqueued 8.86408863197179
Thread 5 enqueued 5.13654995317669
Thread 5 enqueued 4.2210886147538
Thread 4 enqueued 6.94064174636395
thread 6 dequeued 6.39390993005694
thread 6 dequeued 0.337993319585337
thread 6 dequeued 4.34504733960242
thread 6 dequeued 2.89158054485114
thread 6 dequeued 9.4947585773571
thread 6 dequeued 3.17079715055542
thread 6 dequeued 8.86408863197179
thread 6 dequeued 5.13654995317669
thread 6 dequeued 4.2210886147538
thread 6 dequeued 6.94064174636395

您可以看到5设法在4之前排除了一些内容。线程78无法出列任何内容,6过快。此外,所有入队者都在产生出列人员之前完成(对于如此少量的输入)。