Ruby 多线程

  每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。

  线程是程序中一个单一的顺序控制流程,在单个程序中同时运行多个线程完成不同的工作,称为多线程。

  Ruby 中我们可以通过 Thread 类来创建多线程,Ruby的线程是一个轻量级的,可以以高效的方式来实现并行的代码。

  创建 Ruby 线程

  要启动一个新的线程,只需要调用 Thread.new 即可:

  # 线程 #1 代码部分

  Thread.new {

  # 线程 #2 执行代码

  }

  # 线程 #1 执行代码

  实例

  以下实例展示了如何在Ruby程序中使用多线程:

  #!/usr/bin/ruby

  def func1

  i=0

  while i<=2

  puts "func1 at: #{Time.now}"

  sleep(2)

  i=i+1

  end

  end

  def func2

  j=0

  while j<=2

  puts "func2 at: #{Time.now}"

  sleep(1)

  j=j+1

  end

  end

  puts "Started At #{Time.now}"

  t1=Thread.new{func1()}

  t2=Thread.new{func2()}

  t1.join

  t2.join

  puts "End at #{Time.now}"

  以上代码执行结果为:

  Started At Wed May 14 08:21:54 -0700 2014

  func1 at: Wed May 14 08:21:54 -0700 2014

  func2 at: Wed May 14 08:21:54 -0700 2014

  func2 at: Wed May 14 08:21:55 -0700 2014

  func1 at: Wed May 14 08:21:56 -0700 2014

  func2 at: Wed May 14 08:21:56 -0700 2014

  func1 at: Wed May 14 08:21:58 -0700 2014

  End at Wed May 14 08:22:00 -0700 2014

  线程生命周期

  1、线程的创建可以使用Thread.new,同样可以以同样的语法使用Thread.start 或者Thread.fork这三个方法来创建线程。

  2、创建线程后无需启动,线程会自动执行。

  3、Thread 类定义了一些方法来操控线程。线程执行Thread.new中的代码块。

  4、线程代码块中最后一个语句是线程的值,可以通过线程的方法来调用,如果线程执行完毕,则返回线程值,否则不返回值直到线程执行完毕。

  5、Thread.current 方法返回表示当前线程的对象。 Thread.main 方法返回主线程。

  6、通过 Thread.Join 方法来执行线程,这个方法会挂起主线程,直到当前线程执行完毕。

  线程状态

  线程有5种状态:

  线程状态返回值

  Runnablerun

  SleepingSleeping

  Abortingaborting

  Terminated normallyfalse

  Terminated with exceptionnil

  线程和异常

  当某线程发生异常,且没有被rescue捕捉到时,该线程通常会被无警告地终止。但是,若有其它线程因为Thread#join的关系一直等待该线程的话,则等待的线程同样会被引发相同的异常。

  begin

  t = Thread.new do

  Thread.pass # 主线程确实在等join

  raise "unhandled exception"

  end

  t.join

  rescue

  p $! # => "unhandled exception"

  end

  使用下列3个方法,就可以让解释器在某个线程因异常而终止时中断运行。

  启动脚本时指定-d选项,并以调试模时运行。

  用Thread.abort_on_exception设置标志。

  使用Thread#abort_on_exception对指定的线程设定标志。

  当使用上述3种方法之一后,整个解释器就会被中断。

  t = Thread.new { ... }

  t.abort_on_exception = true

  线程同步控制

  在Ruby中,提供三种实现同步的方式,分别是:

  1. 通过Mutex类实现线程同步

  2. 监管数据交接的Queue类实现线程同步

  3. 使用ConditionVariable实现同步控制

  通过Mutex类实现线程同步

  通过Mutex类实现线程同步控制,如果在多个线程钟同时需要一个程序变量,可以将这个变量部分使用lock锁定。 代码如下:

  #encoding:gbk

  require "thread"

  puts "Synchronize Thread"

  @num=200

  @mutex=Mutex.new

  def buyTicket(num)

  @mutex.lock

  if @num>=num

  @num=@num-num

  puts "you have successfully bought #{num} tickets"

  else

  puts "sorry,no enough tickets"

  end

  @mutex.unlock

  end

  ticket1=Thread.new 10 do

  10.times do |value|

  ticketNum=15

  buyTicket(ticketNum)

  sleep 0.01

  end

  end

  ticket2=Thread.new 10 do

  10.times do |value|

  ticketNum=20

  buyTicket(ticketNum)

  sleep 0.01

  end

  end

  sleep 1

  ticket1.join

  ticket2.join

  输出结果如下:

  Synchronize Thread

  you have successfully bought 15 tickets

  you have successfully bought 20 tickets

  you have successfully bought 15 tickets

  you have successfully bought 20 tickets

  you have successfully bought 15 tickets

  you have successfully bought 20 tickets

  you have successfully bought 15 tickets

  you have successfully bought 20 tickets

  you have successfully bought 15 tickets

  you have successfully bought 20 tickets

  you have successfully bought 15 tickets

  sorry,no enough tickets

  sorry,no enough tickets

  sorry,no enough tickets

  sorry,no enough tickets

  sorry,no enough tickets

  sorry,no enough tickets

  sorry,no enough tickets

  sorry,no enough tickets

  sorry,no enough tickets

  除了使用lock锁定变量,还可以使用try_lock锁定变量,还可以使用Mutex.synchronize同步对某一个变量的访问。

  监管数据交接的Queue类实现线程同步

  Queue类就是表示一个支持线程的队列,能够同步对队列末尾进行访问。不同的线程可以使用统一个对类,但是不用担心这个队列中的数据是否能够同步,另外使用SizedQueue类能够限制队列的长度

  SizedQueue类能够非常便捷的帮助我们开发线程同步的应用程序,应为只要加入到这个队列中,就不用关心线程的同步问题。

  经典的生产者消费者问题:

  #encoding:gbk

  require "thread"

  puts "SizedQuee Test"

  queue = Queue.new

  producer = Thread.new do

  10.times do |i|

  sleep rand(i) # 让线程睡眠一段时间

  queue << i

  puts "#{i} produced"

  end

  end

  consumer = Thread.new do

  10.times do |i|

  value = queue.pop

  sleep rand(i/2)

  puts "consumed #{value}"

  end

  end

  consumer.join

  程序的输出:

  SizedQuee Test

  0 produced

  1 produced

  consumed 0

  2 produced

  consumed 1

  consumed 2

  3 produced

  consumed 34 produced

  consumed 4

  5 produced

  consumed 5

  6 produced

  consumed 6

  7 produced

  consumed 7

  8 produced

  9 produced

  consumed 8

  consumed 9

  使用ConditionVariable实现同步控制

  使用 ConditonVariable进行同步控制,能够在一些致命的资源竞争部分挂起线程直到有可用的资源为止。

  #encoding:gbk

  require "thread"

  puts "thread synchronize by ConditionVariable"

  mutex = Mutex.new

  resource = ConditionVariable.new

  a = Thread.new {

  mutex.synchronize {

  # 这个线程目前需要resource这个资源

  resource.wait(mutex)

  puts "get resource"

  }

  }

  b = Thread.new {

  mutex.synchronize {

  #线程b完成对resourece资源的使用并释放resource

  resource.signal

  }

  }

  a.join

  puts "complete"

  mutex 是声明的一个资源,然后通过ConditionVariable来控制申请和释放这个资源。

  b 线程完成了某些工作之后释放资源resource.signal,这样a线程就可以获得一个mutex资源然后进行执行。 执行结果:

  thread synchronize by ConditionVariable

  get resource

  complete

  线程类方法

  完整的 Thread(线程) 类方法如下:

  序号方法描述

  1Thread.abort_on_exception

  若其值为真的话,一旦某线程因异常而终止时,整个解释器就会被中断。它的默认值是假,也就是说,在通常情况下,若某线程发生异常且该异常未被Thread#join等检测到时,该线程会被无警告地终止。

  2Thread.abort_on_exception=

  如果设置为 true, 一旦某线程因异常而终止时,整个解释器就会被中断。返回新的状态

  3Thread.critical

  返回布尔值。

  4Thread.critical=

  当其值为true时,将不会进行线程切换。若当前线程挂起(stop)或有信号(signal)干预时,其值将自动变为false。

  5Thread.current

  返回当前运行中的线程(当前线程)。

  6Thread.exit

  终止当前线程的运行。返回当前线程。若当前线程是唯一的一个线程时,将使用exit(0)来终止它的运行。

  7Thread.fork { block }

  与 Thread.new 一样生成线程。

  8Thread.kill( aThread )

  终止线程的运行.

  9Thread.list

  返回处于运行状态或挂起状态的活线程的数组。

  10Thread.main

  返回主线程。

  11Thread.new( [ arg ]* ) {| args | block }

  生成线程,并开始执行。数会被原封不动地传递给块. 这就可以在启动线程的同时,将值传递给该线程所固有的局部变量。

  12Thread.pass

  将运行权交给其他线程. 它不会改变运行中的线程的状态,而是将控制权交给其他可运行的线程(显式的线程调度)。

  13Thread.start( [ args ]* ) {| args | block }

  生成线程,并开始执行。数会被原封不动地传递给块. 这就可以在启动线程的同时,将值传递给该线程所固有的局部变量。

  14Thread.stop

  将当前线程挂起,直到其他线程使用run方法再次唤醒该线程。

  线程实例化方法

  以下实例调用了线程实例化方法 join:

  #!/usr/bin/ruby

  thr = Thread.new do # 实例化

  puts "In second thread"

  raise "Raise exception"

  end

  thr.join # 调用实例化方法 join

  以下是完整实例化方法列表:

  序号方法描述

  1thr[ name ]

  取出线程内与name相对应的固有数据。 name可以是字符串或符号。 若没有与name相对应的数据时, 返回nil。

  2thr[ name ] =

  设置线程内name相对应的固有数据的值, name可以是字符串或符号。 若设为nil时, 将删除该线程内对应数据。

  3thr.abort_on_exception

  返回布尔值。

  4thr.abort_on_exception=

  若其值为true的话,一旦某线程因异常而终止时,整个解释器就会被中断。

  5thr.alive?

  若线程是"活"的,就返回true。

  6thr.exit

  终止线程的运行。返回self。

  7thr.join

  挂起当前线程,直到self线程终止运行为止. 若self因异常而终止时, 将会当前线程引发同样的异常。

  8thr.key?

  若与name相对应的线程固有数据已经被定义的话,就返回true

  9thr.kill

  类似于 Thread.exit 。

  10thr.priority

  返回线程的优先度. 优先度的默认值为0. 该值越大则优先度越高.

  11thr.priority=

  设定线程的优先度. 也可以将其设定为负数.

  12thr.raise( anException )

  在该线程内强行引发异常.

  13thr.run

  重新启动被挂起(stop)的线程. 与wakeup不同的是,它将立即进行线程的切换. 若对死进程使用该方法时, 将引发ThreadError异常.

  14thr.safe_level

  返回self 的安全等级. 当前线程的safe_level与$SAFE相同.

  15thr.status

  使用字符串"run"、"sleep"或"aborting" 来表示活线程的状态. 若某线程是正常终止的话,就返回false. 若因异常而终止的话,就返回nil。

  16thr.stop?

  若线程处于终止状态(dead)或被挂起(stop)时,返回true.

  17thr.value

  一直等到self线程终止运行(等同于join)后,返回该线程的块的返回值. 若在线程的运行过程中发生了异常, 就会再次引发该异常.

  18thr.wakeup

  把被挂起(stop)的线程的状态改为可执行状态(run), 若对死线程执行该方法时,将会引发ThreadError异常。

  (编辑:雷林鹏 来源:网络)

雷林鹏分享:Ruby 多线程的更多相关文章

  1. 雷林鹏分享:Ruby 循环

    Ruby 循环 Ruby 中的循环用于执行相同的代码块若干次.本章节将详细介绍 Ruby 支持的所有循环语句. Ruby while 语句 语法 while conditional [do] code ...

  2. 雷林鹏分享:Ruby Socket 编程

    Ruby Socket 编程 Ruby提供了两个级别访问网络的服务,在底层你可以访问操作系统,它可以让你实现客户端和服务器为面向连接和无连接协议的基本套接字支持. Ruby 统一支持应用程的网络协议, ...

  3. 雷林鹏分享:C# 多线程

    C# 多线程 线程 被定义为程序的执行路径.每个线程都定义了一个独特的控制流.如果您的应用程序涉及到复杂的和耗时的操作,那么设置不同的线程执行路径往往是有益的,每个线程执行特定的工作. 线程是轻量级进 ...

  4. 雷林鹏分享:Ruby 安装 - Windows

    Ruby 安装 - Windows 下面列出了在 Windows 机器上安装 Ruby 的步骤. 注意:在安装时,您可能有不同的可用版本. 下载最新版的 Ruby 压缩文件.请点击这里下载. 下载 R ...

  5. 雷林鹏分享:Ruby 安装 - Unix

    Ruby 安装 - Unix 下面列出了在 Unix 机器上安装 Ruby 的步骤. 注意:在安装之前,请确保您有 root 权限. 下载最新版的 Ruby 压缩文件.请点击这里下载. 下载 Ruby ...

  6. 雷林鹏分享:Ruby 命令行选项

    Ruby 命令行选项 Ruby 一般是从命令行运行,方式如下: $ ruby [ options ] [.] [ programfile ] [ arguments ... ] 解释器可以通过下列选项 ...

  7. 雷林鹏分享:Ruby 语法

    Ruby 语法 让我们编写一个简单的 Ruby 程序.所有的 Ruby 文件扩展名都是 .rb.所以,把下面的源代码放在 test.rb 文件中. #!/usr/bin/ruby -w puts &q ...

  8. 雷林鹏分享:Ruby 环境变量

    Ruby 环境变量 Ruby 解释器使用下列环境变量来控制它的行为.ENV 对象包含了所有当前设置的环境变量列表. 变量描述 DLN_LIBRARY_PATH动态加载模块搜索的路径. HOME当没有参 ...

  9. 雷林鹏分享:Ruby 类和对象

    Ruby 类和对象 Ruby 是一种完美的面向对象编程语言.面向对象编程语言的特性包括: 数据封装 数据抽象 多态性 继承 这些特性将在 面向对象的 Ruby 中进行讨论. 一个面向对象的程序,涉及到 ...

随机推荐

  1. Vue2.0 新手完全填坑攻略——从环境搭建到发布

    Jinkey原创感谢 showonne.yubang 技术指导Demo 地址:http://demo.jinkey.io/vue2源码:https://github.com/Jinkeycode/vu ...

  2. nginx 上php不可写解决方法

    在php.ini中设置的session.save_path会被php-fpm.conf中覆盖 打开php-fpm.conf文件找到php_value['session.save_apth'] 这里的/ ...

  3. MyBatis 内置日志工厂基于运行时自省机制选择合适的日志工具

    mybatis – MyBatis 3 | 日志 http://www.mybatis.org/mybatis-3/zh/logging.html MyBatis 内置日志工厂基于运行时自省机制选择合 ...

  4. DNS的MX记录和CNAME记录(转)

    MX记录就是邮件域名对邮件服务器(域名)的映射.可以映射到多个邮件服务器,发送时会选择一台发送. 拿到新域名后,还要再查找DNS,将域名转不ip 原文:http://my.oschina.net/u/ ...

  5. Mirror--程序访问镜像数据库的超时机制

    程序在访问有镜像的数据库和无镜像的数据库时,采用的链接超时时间算法不一样,因此会导致在在有镜像的数据库上设置了15 S的超时时间,而实际的超时时间仅为3.6 S,从而导致有镜像的数据库更容易超时. 在 ...

  6. linux 安装 mysql-5.6.26

    linux安装mysql-5.6.26 查看工具:winscp 下载地址 http://mirrors.sohu.com/mysql/MySQL-5.6/ 文件: mysql-5.6.26-linux ...

  7. python之__setattr__常见问题

    #__setattr__ class Foo(object): def set(self,k,v): pass def __setattr__(self, key, value): print(key ...

  8. com.sun.image.codec.jpeg在Eclipse中报错的解决办法

    在Eclipse中处理图片,需要引入两个包:import com.sun.image.codec.jpeg.JPEGCodec;import com.sun.image.codec.jpeg.JPEG ...

  9. php中的set_magic_quotes_runtime()作用和用法

    set_magic_quotes_runtime 用来设置php.ini文件中的magic_quotes_runtime值,当遇到反斜杆(\).单引号(').双引号(")这样一些的字符定入到 ...

  10. (转)关于EntityFramework中连接字符串的说明

    1. 基本格式 <connectionStrings> <add name="MyEntities" connectionString="metadat ...