线程

线程概述

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

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

线程的生成

可以使用Thread.start方法来生成新线程。其用法如下：

Thread.start { .... }

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

1  Thread.start {

2     while true

3        print "thread 1\n"

4     end

5  }

6

7  while true

8     print "thread 2\n"

9  end

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

线程的操作

线程类的方法如下：

Thread.start {...}

Thread.new {...}

生成新线程，并对迭代程序块进行判断。返回新生成的线程对象。new是start的别名。

Thread.current

返回当前运行的线程对象。

Thread.exit

终止当前运行的线程对象。

Thread.join thread

挂起现在的线程，直到指定线程运行结束为止。

Thread.kill thread

终止指定线程的运行。

Thread.pass

将控制权显式地交给其他可运行的线程。

Thread.stop

挂起现在的线程，直到其他线程运行thread#run为止。

Thread#exit

终止receiver线程。

Thread#run

重新开启receiver线程。

Thread#stop

挂起receiver线程。

Thread#status

若receiver线程存在则返回真。若线程因错误而终止，则引发那个错误。

Thread#value

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

线程间的同步

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

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

require "thread"

Mutex

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

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

begin

m.lock

# 访问受m保护的共享数据

ensure

m.unlock

end

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

m.synchronize {

# 访问受m保护的共享数据

}

举个简单的例子。

1  require "thread"

2

3  m = Mutex.new

4  v = 0;                # 受m保护的数据

5

6  Thread.start {

7     while true

8        m.synchronize {

9          v = v + 100

10        }

11     end

12  }

13

14  while true

15     m.synchronize {

16        v = v - 33

17    }

18  end

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