Ruby多线程编程初步入门

 传统程序有一个单独的线程执行，包含该程序的语句或指令顺序执行直到程序终止。

一个多线程的程序有多个线程的执行。在每个线程是按顺序执行的，但是在多核cpu机器上线程可能并行地执行。例如，通常情况下在单一cpu的机器，多个线程实际上不是并行执行的，而是模拟并行交叉的线程的执行。

ruby的可以使用 thread 类很容易地编写多线程程序。 ruby线程是一个轻量级的和高效的在代码中实现并行性。
创建ruby线程：

要启动一个新线程，关联一个块通过调用thread.new。将创建一个新的线程执行的代码块，原始线程将立即从thread.new返回并继续执行下一个语句：

# thread #1 is running here
thread.new {
 # thread #2 runs this code
}
# thread #1 runs this code

例如：

这里是一个例子说明，我们如何能够利用多线程的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 2008
func1 at: wed may 14 08:21:54 -0700 2008
func2 at: wed may 14 08:21:54 -0700 2008
func2 at: wed may 14 08:21:55 -0700 2008
func1 at: wed may 14 08:21:56 -0700 2008
func2 at: wed may 14 08:21:56 -0700 2008
func1 at: wed may 14 08:21:58 -0700 2008
end at wed may 14 08:22:00 -0700 2008

线程的生命周期：

创建一个新的线程用 thread.new。也可以使用了同义词用 thread.start 和 thread.fork。

没有必要启动一个线程在它被创建后，它会自动开始运行时，cpu 资源成为可用。

thread 类定义了一些方法来查询和处理的线程在运行时。运行一个线程块中的代码调用thread.new，然后它停止运行。

该块中的最后一个表达式的值是线程的值，可以通过调用 thread对象值的方法。如果线程运行完成，则该值为线程的返回值。否则，该值方法会阻塞不会返回，直到该线程已完成。
类方法thread.current返回代表当前线程的 thread对象。这允许线程操纵自己。类方法 thread.main返回线程对象代表主线程，thread.this初始线程开始执行ruby程序开始时。

可以等待一个特定的线程通过调用该线程的thread.join方法来完成。调用线程将被阻塞，直到给定线程完成。
线程和异常：

如果在主线程中引发一个异常，并没有任何地方处理，ruby解释器打印一条消息并退出。在主线程以外的其他线程，未处理的异常导致线程停止运行。

如果线程 t 退出，因为未处理的异常，而另一个线程调用t.join或t.value，那么所发生的异常在 t 中提出的线程 s。

如果 thread.abort_on_exception 为 false，默认情况下，出现未处理的异常只是杀死当前线程和所有其余的继续运行。

如果想在任何线程中的任何未处理的异常导致解释退出中，设置类方法thread.abort_on_exception 为 true。

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

线程变量：

一个线程可以正常访问是在范围内的任何变量的线程被创建时。一个线程块的局部变量是线程的局部，而不是共享。

thread类提供一个特殊的功能，允许通过名称来创建和存取线程局部变量。只需把线程对象，如果它是一个hash，写入元素使用[] =和读取他们带回使用[]。

在这个例子中，每个线程记录计数变量的当前值与该键mycount的一个threadlocal变量。

#!/usr/bin/ruby

count = 0
arr = []

10.times do |i|
  arr[i] = thread.new {
   sleep(rand(0)/10.0)
   thread.current["mycount"] = count
   count += 1
  }
end

arr.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线程对象的优先级=和优先级的优先级。新创建的线程开始在相同的优先级的线程创建它。启动主线程优先级为0。

没有任何方法设置线程优先级在开始运行前。然而，一个线程可以提高或降低自己的优先级的第一次操作。
线程排斥：

如果两个线程共享访问相同的数据，至少有一个线程修改数据，你必须要特别小心，以确保任何线程都不能看到数据处于不一致的状态。这称为线程排除。

mutex类是一些共享资源的互斥访问，实现了一个简单的信号锁定。即，只有一个线程可持有的锁在给定时间。其他线程可能选择排队等候的锁变得可用，或者可以简单地选择立即得到错误，表示锁定不可用。

通过将所有访问共享数据的互斥体的控制下，我们确保一致性和原子操作。我们的尝试例子，第一个无需mutax，第二个使用mutax：
无需mutax的例子：

#!/usr/bin/ruby
require 'thread'

count1 = count2 = 0
difference = 0
counter = thread.new do
  loop do
   count1 += 1
   count2 += 1
  end
end
spy = thread.new do
  loop do
   difference += (count1 - count2).abs
  end
end
sleep 1
puts "count1 : #{count1}"
puts "count2 : #{count2}"
puts "difference : #{difference}"

这将产生以下结果：

count1 : 1583766
count2 : 1583766
difference : 637992

#!/usr/bin/ruby
require 'thread'
mutex = mutex.new

count1 = count2 = 0
difference = 0
counter = thread.new do
  loop do
   mutex.synchronize do
     count1 += 1
     count2 += 1
   end
  end
end
spy = thread.new do
  loop do
    mutex.synchronize do
     difference += (count1 - count2).abs
    end
  end
end
sleep 1
mutex.lock
puts "count1 : #{count1}"
puts "count2 : #{count2}"
puts "difference : #{difference}"

这将产生以下结果：

count1 : 696591
count2 : 696591
difference : 0

处理死锁：

当我们开始使用互斥对象的线程排除，我们必须小心地避免死锁。死锁的情况发生时，所有线程正在等待获取另一个线程持有的资源。因为所有的线程被阻塞，他们不能释放其所持有的锁。因为他们可以不释放锁，其它线程不能获得这些锁。

一个条件变量仅仅是一个信号，与资源相关联，并用于特定互斥锁的保护范围内的。当需要一个资源不可用，等待一个条件变量。这一行动释放相应的互斥锁。当一些其他线程发送信号的资源是可用的，原来的线程来等待，并同时恢复上的锁临界区。
例子：

#!/usr/bin/ruby
require 'thread'
mutex = mutex.new

cv = conditionvariable.new
a = 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.join
b.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 cv
b: i am still critical, finishing up
a: i have critical section again! i rule!

线程状态：

有五种可能的返回值对应于下表中所示的5个可能的状态。该的状态方法返回的线程状态。

 thread类的方法：

thread类提供以下方法，它们适用程序的所有线程。这些方法它们使用thread类的名称来调用，如下所示：

thread.abort_on_exception = true

这里是所有类方法的完整列表：

 线程实例方法：

这些方法是适用于一个线程的一个实例。这些方法将被调用，使用一个线程的一个实例如下：

#!/usr/bin/ruby

thr = thread.new do  # calling a class method new
  puts "in second thread"
  raise "raise exception"
end
thr.join  # calling an instance method join

这里是所有实例方法的完整列表：