Perl 中的线程（2）

最新推荐文章于 2019-03-26 19:28:32 发布
最新推荐文章于 2019-03-26 19:28:32 发布
阅读量668 收藏
点赞数
分类专栏： PERL学习笔记

<<=========================threads===========================>>

#!/usr/bin/perl
use threads ('yield',
            'stack_size' => 64*4096,
            'exit' => 'threads_only',
            'stringify');
 
sub start_thread {
   my @args = @_;
   print('Thread started: ', join(' ', @args), "\n");
}
 
##创建线程的方法
# my $thr = threads->create('func_name', ...);
# my $thr = threads->create(sub { ... }, ...);
# my $thr = threads->create(\&func, ...);
# The "->new()" method is an alias for "->create()".
my $thr = threads->create('start_thread', 'argument1', 'argument2');     #通过create创建线程。返回线程实例
$thr->join();                #等待线程结束
threads->create(sub { print("I am a thread\n"); })->join();                   #创建一个线程，没有返回值。那这个线程实例如何访问呢？
 
my $thr2 = async { foreach (@ARGS) { print"$_\n"; } };                              #通过async使用匿名子例程创建线程
$thr2->join();
if (my $err = $thr2->error()) {
   warn("Thread error: $err\n");
}
 
# 在隐式的列表环境中调用thread
my $thr3 = threads->create(sub { return (qw/a b c/); });
# 在显式的列表环境中调用thread
my $thr4 = threads->create({'context' => 'list'},
                         sub { return (qw/a b c/); });
# 由于创建线程时使用的子例程返回的是列表，所以这里的join函数返回的也是列表
my @results = $thr3->join();
print "@results\n";
# 把线程从主线程中分离出来
# $thr->detach();        ##报错：Cannot detach a joined thread,因为$thr已经调用过join()
$thr4->detach();     ##
$tid = $thr4->tid();
print "线程4ID：$tid\n";
 
# Get a thread's object
$thr6 = threads->self();
$thr7 = threads->object($tid);
 
# Get a thread's ID
$tid = threads->tid();
$tid = "$thr7";     #根据线程实例获得线程ID
 
# 给其他线程一个运行的机会
threads->yield();
yield();
 
# 返回未分离的线程列表
my @threads = threads->list();
my $thread_count = threads->list();
 
my @running = threads->list(threads::running);
my @joinable = threads->list(threads::joinable);
 
# 判断两个线程是相同
if ($thr4 == $thr2) {
   print "thread4 equals to thread2.\n";
}
 
# 管理线程栈大小
$stack_size = threads->get_stack_size();
$old_size = threads->set_stack_size(32*4096);
 
# Create a thread with a specific context and stack size
my $thr5 = threads->create({ 'context'    => 'list',
                           'stack_size' => 32*4096,
                           'exit'       => 'thread_only' },
                         \&start_thread);
 
# Get thread's context
my $wantarray = $thr->wantarray();
print $wantarray,"\n";
 
# Check thread's state
if ($thr5->is_running()) {
   sleep(1);
}
if ($thr5->is_joinable()) {
   $thr5->join();
}
 
# Send a signal to a thread
$thr5->kill('SIGUSR1');
 
# Exit a thread
threads->exit();                                    

<<=========================Thread========================>>

$thread = Thread->new(\&start_sub)

$thread = Thread->new(\&start_sub,@args)

start_sub指定线程要执行的子例程，args是传给子例程的参数。

lock  VARIABLE

给变量加锁，直到锁超出范围。 给变量加锁只影响到lock函数的调用--即一个线程lock var1后，另一个线程再调用lovk var1时线程就会阻塞，但 lock  VARIABLE并不影响正常的对变量的访问。

如果锁往的是一个容器（如哈希或数组），那么其中的每一个元素并没有全部被锁住。比如一个线程中调用lock  @arr，在另一个线程中调用lock $arr[3]时并不会阻塞。

async  BLOCK;

async函数创建并返回一个线程实例，该线程要执行的代码全在BLOCK中，这里BLOCK是个匿名子例程，所以其后一定加分号。

Thread->self

返回调用 Thread->self函数的线程实例。

Thread->list

返回non-joined和non-detached线程实例。

cond_wait LOCKED_VARIALBLE

cond_signal  LOCKED_VARIALBLE

cond_broadcast   LOCKED_VARIALBLE

上面3个函数主要用于线程问同步，都以一个已加锁的变量作为输入参数。当一个线程调用cond_wait后阻塞自己；当一个线程发出cond_broadcast后所有阻塞的线程得救；当一个线程发出 cond_signal后只有一个阻塞的线程得救，至于是哪一个由系统内部决定。当然只有 LOCKED_VARIALBLE参数相同时才为一组，大家才可以在一起玩同步。

yield

把CPU控制权交给另外一个线程，至于是哪个线程依赖于当时的运行环境。

join

等待一个线程结束并返回该线程结束时的返回值。

detach

分离的线程不允许被join。

equal

判断两个线程是否相同。

tid

返回线程的tid。tid是递增的，main线程的tid为0。

done

判断线程是否已经结束。

下面这3个函数在5005threads中还可以用，但是在ithreads中已经不可用了。

lock(\&sub)　　　　eval　　　　flags

<<============================threads::shared============================>>

默认下数据都是线程私有的，新创建的线程获得已有变量的一份私有拷贝。 threads::shared用于在线程之间共享数据结构，可共享的数据类型只有6种，标量数据、数组、散列、以及它们的引用。

声明共享变量：

my ($scalar, @array, %hash);             

share($scalar);             

share(@array);           

 share(%hash);

share函数返回共享的值，这通常是一个引用。

也可以在编译时标记变量为共享变量：

my ($var, %hash, @array) :shared;

my ($var, %hash, @array) :shared;
             my $bork;
 
             # Storing scalars
             $var = 1;
             $hash{'foo'} = 'bar';
             $array[0] = 1.5;
 
             # Storing shared refs
             $var = \%hash;
             $hash{'ary'} = \@array;
             $array[1] = \$var;
 
             # 不能把非共享变量的引赋给一个共享变量，下面这3句是错误的
             #   $var = \$bork;                    # ref of non-shared variable
             #   $hash{'bork'} = [];               # non-shared array ref
             #   push(@array, { 'x' => 1 });       # non-shared hash ref

shared_clone REF

 my $obj = {'foo' => [qw/foo bar baz/]};           

 bless($obj, 'Foo');             

my $cpy = shared_clone($obj); 

# Object status (i.e., the class an object is blessed into) is also  cloned.           

print(ref($cpy), "\n");         # Outputs 'Foo'

对于克隆空的数组或散列，下面用法是等价的：

$var = &share([]);   # Same as $var = shared_clone([]);             

$var = &share({});   # Same as $var = shared_clone({});

is_shared VARIABLE

判断变量是否为共享变量，如果是则返回变量的内部ID（类似于refaddr函数），如果不是返回undef。

如果is_shared参数是数组或散列，它并不检查容器中的元素是否为共享变量。如下

my %hash :shared;
             if (is_shared(%hash)) {
                 print("\%hash is shared\n");
             }
 
             $hash{'elem'} = 1;
             if (is_shared($hash{'elem'})) {                          ##返回undef
                 print("\$hash{'elem'} is in a shared hash\n");
             }

 lock VARIABLE

不能对容器内部的变量进行加锁：

 my %hash :shared;             

$hash{'foo'} = 'bar';           

 #lock($hash{'foo'});          # Error           

 lock(%hash);                  # Works

cond_wait VARIABLE

cond_signal VARIABLE

cond_broadcast VARIABLE

这3个函数就不说了，跟threads里的一样。

cond_wait CONDVAR, LOCKVAR

当有其他线程signal第一个参数变量CONDVAR时，第二个参数变量LOCKVAR被解锁。

cond_timedwait VARIABLE, ABS_TIMEOUT       

cond_timedwait CONDVAR, ABS_TIMEOUT, LOCKVAR

如果signal未到达，而timeout了，同样会把变量解锁。

#  创建一个共享的'Foo' object
      my $foo :shared = shared_clone({});
      bless($foo, 'Foo');
 
      # 创建一个共享的 'Bar' object
      my $bar :shared = shared_clone({});
      bless($bar, 'Bar');
 
      # 把'bar' 放到 'foo'里面
      $foo->{'bar'} = $bar;
 
      # 通过线程重新bless the objects
      threads->create(sub {
          # Rebless the outer object
          bless($foo, 'Yin');
 
          # 不能直接 rebless the inner object
          #bless($foo->{'bar'}, 'Yang');
 
          # 重新取回然后 rebless the inner object
          my $obj = $foo->{'bar'};
          bless($obj, 'Yang');
          $foo->{'bar'} = $obj;
 
      })->join();
 
      print(ref($foo),          "\n");    # Prints 'Yin'
      print(ref($foo->{'bar'}), "\n");    # Prints 'Yang'
      print(ref($bar),          "\n");    # Also prints 'Yang'
注意：如果你还想使用threads，那么你必须在"use threads::shared" 之前 就"use threads"，否则会报告异常。

如果你把一个数组、散列或它们的引用share以后，那么容器中的元素都会丢失。

my @arr = qw(foo bar baz);
        share(@arr);
        # @arr is now empty (i.e., == ());
 
        # Create a 'foo' object
        my $foo = { 'data' => 99 };
        bless($foo, 'foo');
 
        # Share the object
        share($foo);        # Contents are now wiped out
        print("ERROR: \$foo is empty\n")
            if (! exists($foo->{'data'}));

所以正确的做法是你应该先把一个空的容器share，然后再往里面添加元素。

<<========================Thread::Semaphore=============================>>

use Thread::Semaphore;
           my $s = Thread::Semaphore->new();
           $s->down();   # P操作
           # The guarded section is here
           $s->up();     # V操作
 
           # Decrement the semaphore only if it would immediately succeed.
           if ($s->down_nb()) {
               # 邻界区在此
               $s->up();
           }
 
           # 强制降低信号量即使他成为负数
           $s->down_force();
 
           # 创建信号量时指定·初始值
           my $s = Thread::Semaphore->new($initial_value);
           $s->down($down_value);
           $s->up($up_value);
           if ($s->down_nb($down_value)) {
               ...
               $s->up($up_value);
           }
           $s->down_force($down_value);

<<===========================Thread::Queue===================================>>

直接看程序是学习语言的快速方法，注释得很清楚：

01 use strict;
02            use warnings;
03  
04            use threads;
05            use Thread::Queue;
06  
07            my $q = Thread::Queue->new();    # 创建一个空的线程队列
08  
09            # Worker线程
10            my $thr = threads->create(sub {
11                                        while (my $item = $q->dequeue()) {
12                                            #处理$item
13                                        }
14                                     })->detach();
15  
16            # 向线程发送 work
17            $q->enqueue($item1, ...);
18  
19  
20            # 计算队列中有多少项
21            my $left = $q->pending();
22  
23            # 非阻塞地出队
24            if (defined(my $item = $q->dequeue_nb())) {
25                # 处理 $item
26            }
27  
28            # 获取队列中的第2项，注意并没有进行出几队操作
29            my $item = $q->peek(1);
30  
31            # 在队头后面插入两个元素
32            $q->insert(1, $item1, $item2);
33  
34            # 提取队列中的最后两个元素
35            my ($item1, $item2) = $q->extract(-2, 2);

上面代码中出现过的函数我就不介绍了。

下面的数据类型可以放入队列：
普通标题数据;

标量引用;

数组引用;

哈希引用;

以上对象的组合。

my @ary = qw/foo bar baz/;         

 $q->enqueue(\@ary); 　　　　##copy the elements 'foo', 'bar' and 'baz' from @ary into $q。

而对于共享变量，是它的引用进入队列，而没有发生元素的深复制。

my @ary :shared = qw/foo bar baz/;
           $q->enqueue(\@ary);
 
           my $obj = &shared({});
           $$obj{'foo'} = 'bar';
           $$obj{'qux'} = 99;
           bless($obj, 'My::Class');
           $q->enqueue($obj);

->new()　　　　##创建新队列

->new(LIST)　　##创建队列时压入元素

->enqueue(LIST)　　　　#入队

->dequeue()　　　　#从队中取出一个元素

->dequeue(COUNT)　　　　#从队中取出COUNT个元素，如果COUNT大于队列长度，则阻塞，下面的方法不会阻塞。

->dequeue_nb()       

->dequeue_nb(COUNT)

->pending()

返回队列中元素的个数。

{
      lock($q);   # 销往队列，以防止其他线程中修改和删除队列元素
      my $item = $q->peek();
      if ($item ...) {
          ...
      }
  }
  # 离开块之后，队列变量自动解锁

->peek()　　　　　　#取出队首元素，并没有出险

->peek(INDEX)　　　　#取出指定下标的队列元素，INDEX为负数时是从队尾开始数起

->insert(INDEX,LIST)　　　　#在指定的位置上插入一组元素，队首元素的INDEX为0

->extract()

->extract(INDEX)       

->extract(INDEX, COUNT)

删除并返回指定的元素。

【perl语言】利用threads实现多线程运算
weixin_43840576的博客
10-03 679
代码如下 #!/usr/bin/env perl use strict; use threads; use Thread::Semaphore; my $trait = $ARGV[0]; my $NumOfTrait = 0; my $thread; my $max_cpu = 28; my $semaphore = new Thread::Semaphore($max_cpu); my (@line, @line, %traitDict, $i); open REF, "taxa_".$trait
Perl threads 摘要
USTBHacker的专栏
12-27 4507
最近又写了一个多线程的小工具，对一些多线程的使用有了进一步的心得。 Perl 创建线程有两种方式，正常通过threads->create 创建线程，用async  创建一个调用匿名过程的线程，具体参考perldoc threads。线程共享变量需要使用 threads::shared，共享变量只能存储scalar，共享变量的引用，如果存储List Hash的引用需使用shared_clo
Perl Thread
weixin_33755649的博客
05-25 171
perldoc threads　　----　　英文的... ... 网上找不到中文全面介绍的，无奈，哥今天就来翻译一下。 &lt;&lt;=========================threads===========================&gt;&gt; #!/usr/bin/perl use threads ('yield', 'stack...
Perl线程研究 thread
weixin_30632089的博客
02-25 148
我就直接贴代码了。没做什么注释，因为还在修改，目前还有点不太理解，跑去看了下云舒的代码，感觉那个应该有点启发。 回头好好修改下。这些多线程模块还有点不太熟悉，主要跟进程弄乱了。 得好好琢磨下，如果可以改成别的就更爽了。不过他们都说perl多线程不靠谱。。汗。。 #!/usr/bin/perl use Net::Ping; use threads; use threads::shar...
perl多线程
深未来技术
08-01 283
  perl 多线程   http://blog.sina.com.cn/s/blog_4af3f0d20100fcr3.html 例子一：http://yufengseu.spaces.live.com/Blog/cns!31875D62B958914B!138.entry 以前为了方便自己(当然也是为了偷懒^_^)使用perl写了一个脚本来抓取网页,并进行分析以获取我想要的信...
perl 多线程
08-17
Perl 支持线程处理，但在不同的Perl版本中采用了不同的线程模型。 ##### 1. 5005线程模型 - **简介**：这是Perl 5.005版本中首次引入的线程模型。在这个模型下，所有的数据都是共享的。 - **问题**：由于存在许多...
perl中的线程.docx
12-09
以下是对Perl线程的详细解释： 首先，Perl程序的执行顺序通常是线性的，从上到下依次执行代码。例如，在不使用线程的情况下，直接执行子程序，如`sub test0`，会按照定义的顺序依次打印出`test0 0`、`test0 1`和`...
perl实现多线程详解[整理].pdf
10-19
Perl 语言提供了多种多线程实现方式，本文将详细介绍 Perl 语言中多线程实现的方法和技术。 在 Perl 语言中，使用 threads 包可以实现多线程编程。threads 包提供了多种方法来创建和管理线程，包括创建线程、等待...
perl多线程教程集
03-16
二、Perl线程的创建与操作 1. 创建线程：使用`threads->create()`函数可以创建新线程。例如： ```perl my $thread = threads->create(\&subroutine, args); ``` 这里`subroutine`是你希望在线程中运行的子程序，`...
threads:Perl论坛
05-08
线程数 这是一个现代的外观新颖的论坛，主要为Perl杂志 （俄语）撰写。 居住 实时英文版可以在上找到。 如何 如何在本地启动它。 配置 将config/config.yml.example复制到config/config.yml并进行调整以适合您的需求。 数据库设置 cat schema/*.sql | sqlite db.db 或者，您可以使用迁移工具。 见下文。 依赖项安装 提取子模块： git submodule update --init 从CPAN安装模块 带carton ： carton install 使用cpanm ： cpanm -L perl5 --installdeps . 职位 有一些作业需要定期运行以保持数据库的清洁和通知的正常运行。 电子邮件通知： perl util/run-job.pl send_email_notifications 无效的注册
perl thread
weixin_30493321的博客
11-22 110
1 #!/usr/local/bin/perl 2 use threads; 3 4 @domain = ("tom.com", "chinadns.com", "163.com", "aol.com"); 5 for ($i=0;$i<4;$i++) 6 { 7 print $i.'.'.$domain...
【perl】threads多线程telnet批量管理网络设备
liudashang123的博客
02-27 582
我的前一篇博文中已经讲过利用Coro协程模块编写批量telnet的脚本。最近我随“大溜”去了，自学python和C++（学会了perl，融会贯通，学习python是件挺轻松的事情）。多亏了python、C++中文材料丰富，尤其是多线程、并发这一块，让我进一步搞懂了一些概念。并且可以融汇贯通到perl中。 闲话少说，下面讲讲协程、多线程和进程的区别： 一般来说，协程属于线程，线程属于进程。 详...
Perl语言的多线程（二）
weixin_30363981的博客
04-27 152
很多时候使用perl多线程可以达到很不错的效果，可以节约很多时间完成很复杂的工作。但通过perl threads模块的描述文件可以看到，它也有很多缺点。比如说在使用perl多线程的时候，必须的保证所有引用的模块都是支持thread。而在实际应用中，我们很难做到这样。比如我们要多线程，但同时要应用OLE模块去操作activex。 此用例应该是一种很常见的用例。那是不是意味着此时我们不得不放弃使用多线...
perl 线程概述
kongjunlongaa的博客
09-23 425
线程概述 线程是一个单一 的执行流程，它是所有程序执行过程中最小的控制单位，即能被 CPU 所调度的最小任务单元。线程与进程之间既有联系，又完全不同。简单地说，一个线程必然属于某一个进程，而一个进程包含至少一个或者多个线程。早期的计算机 系统一次只能运行一个程序，因此，当有多个程序需要执行的时候，唯一的办法就是让它们排成队，按顺序串行执行。进程的出现打破了这种格局，CPU 资源按时间片被分割
1.Perl 多线程:Threads
weixin_30417487的博客
11-30 252
详情可查看: 1 perldoc threads 调用线程的方法: 1 $thr = threads->create(FUNCTION, ARGS) 2 #This will create a new thread that will begin execution with the 3 #specified entry point function,...
Perl多线程
b0207191的博客
03-26 924
多线程的概念 多线程的概念在所有操作系统的书总都有讲到，所谓多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。多个线程的执行是并发的，也就是在逻辑上“同时”...
2.Perl 多线程:Threads(线程返回值)
weixin_30319153的博客
11-30 195
1 use warnings; 2 use strict; 3 use threads; 4 5 sub TEST{ 6 print "Hello, World!\n"; 7 return (qw/1 2 3 4 'a'/); 8 } 9 10 #返回列表方法1 11 my ($t1) = threads->new('TEST...
Perl线程队列：Thread::Queue
weixin_30952535的博客
02-23 664
(Thread::Queue)队列数据结构(FIFO)是线程安全的，它保证了某些线程从一端写入数据，另一些线程从另一端读取数据。只要队列已经满了，写入操作就自动被阻塞直到有空间支持写操作，只要队列空了，读取操作就会自动阻塞直到队列中有数据可读。这种模式自身就保证了线程安全性。 创建队列 new() new(LIST) new()可以创建一个空队列，或者根据已有的列表创建队列，列表中的元素会按照先后...
Perl线程详解：执行顺序与join操作的作用
在Perl语言中，线程是一种并发执行的机制，允许在单个程序中同时执行多个任务，提高程序的效率和响应性。本文将详细介绍Perl中线程的使用方法和执行流程。 首先，让我们理解Perl的基本执行顺序。在没有引入线程之前...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值