Ruby - 多线程

传统程序有一个执行线程构成程序的语句或指令按顺序执行，直到程序终止.

多线程程序有更多而不是一个执行的线程.在每个线程内，语句是顺序执行的，但是线程本身可以在多核CPU上并行执行.通常在单个CPU机器上，多个线程实际上并不是并行执行，而是通过交错执行线程来模拟并行性.

Ruby可以很容易地编写多线程程序 Thread 类. Ruby线程是一种在代码中实现并发的轻量级高效方法.

创建Ruby线程

要启动一个新线程，只需关联一个块调用 Thread.new .将创建一个新线程来执行块中的代码，原始线程将立即从 Thread.new 返回并继续执行下一个语句 :

# Thread #1 is running hereThread.new {   # Thread #2 runs this code}# Thread #1 runs this code

示例

这是一个示例，它显示了我们如何使用多线程Ruby程序.

#!/usr/bin/rubydef func1   i = 0   while i<=2      puts "func1 at: #{Time.now}"      sleep(2)      i = i+1   endenddef func2   j = 0   while j<=2      puts "func2 at: #{Time.now}"      sleep(1)      j = j+1   endendputs "Started At #{Time.now}"t1 = Thread.new{func1()}t2 = Thread.new{func2()}t1.joint2.joinputs "End at #{Time.now}"

这将产生以下结果 :

Started At Wed May 14 08:21:54 -0700 2008func1 at: Wed May 14 08:21:54 -0700 2008func2 at: Wed May 14 08:21:54 -0700 2008func2 at: Wed May 14 08:21:55 -0700 2008func1 at: Wed May 14 08:21:56 -0700 2008func2 at: Wed May 14 08:21:56 -0700 2008func1 at: Wed May 14 08:21:58 -0700 2008End at Wed May 14 08:22:00 -0700 2008

线程生命周期

使用 Thread.new 创建新线程.您还可以使用同义词 Thread.start 和 Thread.fork .

创建线程后无需启动线程当CPU资源可用时，它会自动开始运行.

Thread类定义了许多在线程运行时查询和操作线程的方法.一个线程运行与 Thread.new 调用相关联的块中的代码，然后它停止运行.

该块中最后一个表达式的值是线程的值，可以通过调用Thread对象的 value 方法获得.如果线程已运行完成，则该值立即返回线程的值.否则， value 方法会阻塞，直到线程完成后才会返回.

类方法 Thread.current 返回Thread表示当前线程的对象.这允许线程自己操纵.类方法 Thread.main 返回表示主线程的Thread对象.这是Ruby程序启动时开始的初始执行线程.

您可以通过调用该线程的 Thread.join 等待特定线程完成方法.调用线程将阻塞，直到给定的线程完成.

线程和异常

如果在主线程中引发异常，而不是在任何地方处理，Ruby解释器打印一条消息并退出.在主线程以外的线程中，未处理的异常会导致线程停止运行.

如果线程 t 由于未处理的异常而退出，而另一个线程 s 调用 t.join或t.value，然后在 s 中引发的异常在 s 中引发>.

如果 Thread.abort_on_exception 是 false ，则默认情况下，未处理的异常只会杀死当前线程以及所有其他线程继续运行.

如果您希望任何线程中的任何未处理的异常导致解释器退出，请将类方法 Thread.abort_on_exception 设置为 true .

t = Thread.new { ... }t.abort_on_exception = true

线程变量

线程通常可以在创建线程时访问范围内的任何变量.线程块本地的变量是线程的本地变量，并且不是共享的.

线程类具有一个特殊功能，允许通过名称创建和访问线程局部变量.您只需将线程对象视为Hash，使用[] =写入元素并使用[]读取它们.

在此示例中，每个线程记录当前的值使用键 mycount 的threadlocal变量中的变量count.

#!/usr/bin/rubycount = 0arr = []10.times do |i|   arr[i] = Thread.new {      sleep(rand(0)/10.0)      Thread.current["mycount"] = count      count += 1   }endarr.each {|t| t.join; print t["mycount"], ", " }puts "count = #{count}"

这会产生以下结果 :

8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10

主线程等待子线程完成，然后打印出每个线程捕获的 count 的值.

线程优先级

影响线程调度的第一个因素是线程优先级:在低优先级线程之前调度高优先级线程.更准确地说，如果没有更高优先级的线程等待运行，线程将只获得CPU时间.

您可以使用优先级设置和查询Ruby Thread对象的优先级= 和优先级.新创建的线程的启动优先级与创建它的线程相同.主线程以优先级0开始.

在线程开始运行之前无法设置线程的优先级.但是，线程可以提升或降低自己的优先级作为第一个操作.

线程排除

如果两个线程共享访问权限相同的数据，并且至少有一个线程修改了该数据，您必须特别注意确保没有线程能够看到处于不一致状态的数据.这称为线程排除.

Mutex 是一个实现简单信号量锁的类，用于对某些共享资源进行互斥访问.也就是说，在给定时间只有一个线程可以保持锁定.其他线程可以选择排队等待锁定变为可用，或者可以简单地选择立即获得错误，指示锁定不可用.

通过将所有访问权限放在共享上在互斥锁的控制下，我们确保一致性和原子操作.让我们尝试一些例子，第一个没有mutax，第二个有mutax :

没有Mutax的例子

#!/usr/bin/rubyrequire 'thread'count1 = count2 = 0difference = 0counter = Thread.new do   loop do      count1 += 1      count2 += 1   endendspy = Thread.new do   loop do      difference += (count1 - count2).abs   endendsleep 1puts "count1 :  #{count1}"puts "count2 :  #{count2}"puts "difference : #{difference}"

这将产生以下结果 :

count1 :  1583766count2 :  1583766difference : 0

演示

#!/usr/bin/rubyrequire 'thread'mutex = Mutex.newcount1 = count2 = 0difference = 0counter = Thread.new do   loop do      mutex.synchronize do         count1 += 1         count2 += 1      end   endendspy = Thread.new do   loop do      mutex.synchronize do         difference += (count1 - count2).abs      end   endendsleep 1mutex.lockputs "count1 :  #{count1}"puts "count2 :  #{count2}"puts "difference : #{difference}"

这将产生以下结果 :

count1 :  696591count2 :  696591difference : 0

处理死锁

当我们开始使用 Mutex 对象进行线程排除时，我们必须是c是为了避免死锁.死锁是当所有线程都在等待获取另一个线程持有的资源时发生的情况.因为所有线程都被阻塞，所以它们无法释放它们所持有的锁.并且因为它们无法释放锁，所以没有其他线程可以获取这些锁.

这是条件变量进入图片的地方. 条件变量只是一个与资源相关联的信号量，用于保护特定的互斥锁.当您需要一个不可用的资源时，您需要等待一个条件变量.该操作会释放相应互斥锁上的锁定.当一些其他线程发出信号表明该资源可用时，原始线程将从等待中恢复，并同时重新获得关键区域的锁定.

示例

#!/usr/bin/rubyrequire 'thread'mutex = Mutex.newcv = ConditionVariable.newa = Thread.new {   mutex.synchronize {      puts "A: I have critical section, but will wait for cv"      cv.wait(mutex)      puts "A: I have critical section again! I rule!"   }}puts "(Later, back at the ranch...)"b = Thread.new {   mutex.synchronize {      puts "B: Now I am critical, but am done with cv"      cv.signal      puts "B: I am still critical, finishing up"   }}a.joinb.join

这将产生以下结果 :

A: I have critical section, but will wait for cv(Later, back at the ranch...)B: Now I am critical, but am done with cvB: I am still critical, finishing upA: I have critical section again! I rule!

线程状态

有五种可能的返回值对应于五种可能的状态，如下表所示. status 方法返回线程的状态.

线程类方法

以下方法是由 Thread 类提供，它们适用于程序中可用的所有线程.这些方法将被称为使用 Thread 类名，如下所示 :

Thread.abort_on_exception = true

线程实例方法

这些方法适用于线程的实例.这些方法将被调用为使用 Thread 的实例，如下所示 :

#!/usr/bin/rubythr = Thread.new do   # Calling a class method new   puts "In second thread"   raise "Raise exception"endthr.join   # Calling an instance method join