Ruby 线程

[size=small][b]线程概述[/b][/size]

[b]线程(Thread)就是指能在一个程序中处理若干控制流的功能。与OS提供的进程不同的是，线程可以共享内存空间。[/b]

Ruby中使用的线程是用户级线程，由Ruby解释器进行切换管理。[color=red]其效率要低于由OS管理线程的效率，且不能使用多个CPU[/color]，这确实是它的缺点。但其优点也很明显，即[color=red]可移植性很高[/color]。

[b]线程的生成[/b]

可以使用[code]Thread.start[/code]方法来生成新线程。其用法如下。

Thread.start { .... }

Thread.start生成新线程后，新线程会对迭代程序块进行判断。举个简单的例子来看一看线程如何运作。

Thread.start {
   while true
      print "thread 1"
   end
}
   while true
      print "thread 2"
   end

程序运行后“thread1”和“thread2”交替出现，可以看出有两个无限循环在同时运作。请按下Ctrl-C来终止程序。

[b]线程的操作[/b]

线程类的方法如下。

[color=red][b]生成新线程，并对迭代程序块进行判断。返回新生成的线程对象。new是start的别名。[/b][/color]

Thread.start {...}
Thread.new {...}

[color=red][b]返回当前运行的线程对象。[/b][/color]

Thread.current

[color=red][b]终止当前运行的线程对象。[/b][/color]

Thread.exit

[color=red][b]挂起现在的线程，直到指定线程运行结束为止。[/b][/color]

Thread.join thread

[color=red][b]终止指定线程的运行。[/b][/color]

Thread.kill thread

[color=red][b]将控制权显式地交给其他可运行的线程。[/b][/color]

Thread.pass

[color=red][b]挂起现在的线程，直到其他线程运行thread#run为止。[/b][/color]

Thread.stop

[color=red][b]终止receiver线程。[/b][/color]

Thread#exit

[color=red][b]重新开启receiver线程。[/b][/color]

Thread#run

[color=red][b]挂起receiver线程。[/b][/color]

Thread#stop

[color=red][b]若receiver线程存在则返回真。若线程因错误而终止，则引发那个错误。[/b][/color]

Thread#status

[color=red][b]返回判断receiver迭代程序块的结果。若判断迭代程序块的过程尚未完成，则等到该线程终止为止。[/b][/color]

Thread#value

线程间的同步

因为线程共享内存空间，所以使用普通的变量就可完成线程间的数据交换工作。但是为了使操作的时机得当，有必要进行同步。若同步失败会引起各种问题，如可能会一直等一个不可能出现的数据而陷入死锁状态，或接收了非预期数据导致难以查找的错误等等。

Ruby的线程库提供了两种同步方法。一种是只负责同步的Mutex，还有一种是兼管数据交接的Queue。若想使用这些库，需要在程序头部调用下列内容。

require "thread"
Mutex

[b]Mutex是mutual-exclusion lock（互斥锁）的简称。若对Mutex加锁时发现已经处于锁定状态时，线程会挂起直到解锁为止。[/b]

在并行访问中保护共享数据时，可以使用下列代码（m是Mutex的实例）。

begin
   m.lock
   # 访问受m保护的共享数据
ensure
   m.unlock
end

Mutex有个synchronize方法可以简化这一过程。

m.synchronize {
   # 访问受m保护的共享数据
}

举个简单的例子。

require "thread"

m = Mutex.new
v = 0;                # 受m保护的数据

Thread.start {
   while true
      m.synchronize {
        v = v + 100
      }
   end
}

while true
   m.synchronize {
      v = v - 33
  }
end

若此程序中不使用Mutex加以保护的话，因为时机问题，在一个线程读取v的数值后还没来得及进行赋值的时候，另一个线程可能已经改变了v的数值。

Mutex有下列方法。

[color=red][b]生成新的互斥锁[/b][/color]

Mutex.new

[color=red][b]加锁。若已经处于加锁状态则会一直等待下去，直到解锁为止。[/b][/color]

Mutex#lock

[color=red][b]解锁。若有其它等锁的线程则会让它们通过。[/b][/color]

Mutex#unlock

[color=red][b]执行从获得锁到解锁全过程的迭代器。[/b][/color]

Mutex#synchronize

[color=red][b]获得锁。若已处于加锁状态，则返回false且不会挂起。[/b][/color]

Mutex#try_lock

[size=small][b]Queue[/b][/size]

[b]Queue就像一条读写数据的管道。提供数据的线程在一边写入数据，而读取数据的线程则在另一边读出数据。若Queue中没有可供读取的数据时，读取数据的线程会挂起等待数据的到来。
[/b]
下面就是一个使用Queue的简单程序。

require "thread"

q = Queue.new

th = Thread.start {
   while line = q.pop
      print line
   end
}

while gets
   q.push $_
end
q.push nil	# 终止标记
th.join

本程序中，一个线程读入一行之后，另一个线程就输出它。若把第3行改成数组，即“q = []”后，线程间失去同步，则程序无法正确运作。

Queue有下列方法。

[color=red][b]生成新的Queue。[/b][/color]

Queue.new

[color=red][b]若Queue为空则返回真。[/b][/color]

Queue.empty?

[color=red][b]向Queue添加value。[/b][/color]

Queue.push value

[color=red][b]从Queue中取出数据。若参数non_block被指定为非假值而且Queue为空时，则引发错误。其他情况下，若Queue为空时，读取数据的线程会被挂起直到有新数据加入。[/b][/color]

Queue.pop [non_block]

例题

让我们来看一看在并行处理编程领域中非常有名的“哲学家就餐”问题。

“哲学家就餐”问题就是指在下述情况下，哲学家如何取得同步的问题。

有N位哲学家围坐在圆桌旁。圆桌中间放着盛满意大利面条的大盘子。另有N把叉子分别放在每位哲学家身旁。哲学家继续思考问题，若觉得饿就会拿起两旁的叉子就餐。吃完后就将叉子放回去。这些哲学家都是绅士，即使很饿也会等到两旁都有叉子可用之后才会就餐。

运行程序后会依次显示当前的状态。各个字符所代表的意义如下。

[b]正在思考问题的哲学家[/b]
[color=red]o:[/color]

[b]正在工作的哲学家[/b]
[color=red]*:[/color]

[b]无人使用的叉子[/b]
[color=red]-:[/color]

[b]正被使用的叉子[/b]
[color=red]|:[/color]

哲学家思考的时间和就餐的时间由随机数决定。

#
# The Dining Philosophers - thread example
#
require "thread"
N=7    # number of philosophers
 $forks = []
 for i in 0..N-1
   $forks[i] = Mutex.new
 end
 $state = "-o"*N

 def wait
   sleep rand(20)/10.0
 end

 def think(n)
   wait();
 end

 def eat(n)
   wait();
 end

 def philosopher(n)
   while true
     think n
     $forks[n].lock
     if not $forks[(n+1)%N].try_lock
       $forks[n].unlock    # avoid deadlock
       next
     end
     $state[n*2] = ?|;
     $state[(n+1)%N*2] = ?|;
     $state[n*2+1] = ?*;
     print $state, "
"
     eat(n)
     $state[n*2] = ?-;
     $state[(n+1)%N*2] = ?-;
     $state[n*2+1] = ?o;
     print $state, "
"
     $forks[n].unlock
     $forks[(n+1)%N].unlock
   end
 end

 for i in 0..N-1
   Thread.start{philosopher(i)}
   sleep 0.1
 end
sleep
exit