线程概述
线程(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来终止程序。
线程的操作
线程类的方法如下。
- 生成新线程,并对迭代程序块进行判断。返回新生成的线程对象。new是start的别名。
- 返回当前运行的线程对象。
- 终止当前运行的线程对象。
- 挂起现在的线程,直到指定线程运行结束为止。
- 终止指定线程的运行。
- 将控制权显式地交给其他可运行的线程。
- 挂起现在的线程,直到其他线程运行thread#run为止。
- 终止receiver线程。
- 重新开启receiver线程。
- 挂起receiver线程。
- 若receiver线程存在则返回真。若线程因错误而终止,则引发那个错误。
- 返回判断receiver迭代程序块的结果。若判断迭代程序块的过程尚未完成,则等到该线程终止为止。
Thread.start {...}
Thread.new {...}
Thread.current
Thread.exit
Thread.join thread
Thread.kill thread
Thread.pass
Thread.stop
Thread#exit
Thread#run
Thread#stop
Thread#status
Thread#value
线程间的同步
因为线程共享内存空间,所以使用普通的变量就可完成线程间的数据交换工作。但是为了使操作的时机得当,有必要进行同步。若同步失败会引起各种问题,如可能会一直等一个不可能出现的数据而陷入死锁状态,或接收了非预期数据导致难以查找的错误等等。
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的数值。
Mutex有下列方法。
- 生成新的互斥锁。
- 加锁。若已经处于加锁状态则会一直等待下去,直到解锁为止。
- 解锁。若有其它等锁的线程则会让它们通过。
- 执行从获得锁到解锁全过程的迭代器。
- 获得锁。若已处于加锁状态,则返回false且不会挂起。
Mutex.new
Mutex#lock
Mutex#unlock
Mutex#synchronize
Mutex#try_lock
Queue
Queue就像一条读写数据的管道。提供数据的线程在一边写入数据,而读取数据的线程则在另一边读出数据。若Queue中没有可供读取的数据时,读取数据的线程会挂起等待数据的到来。
下面就是一个使用Queue的简单程序。
1 require "thread"
2
3 q = Queue.new
4
5 th = Thread.start {
6 while line = q.pop
7 print line
8 end
9 }
10
11 while gets
12 q.push线程概述
线程(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
endMutex有个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的数值。
Mutex有下列方法。
Mutex.new
- 生成新的互斥锁。
Mutex#lock
- 加锁。若已经处于加锁状态则会一直等待下去,直到解锁为止。
Mutex#unlock
- 解锁。若有其它等锁的线程则会让它们通过。
Mutex#synchronize
- 执行从获得锁到解锁全过程的迭代器。
Mutex#try_lock
- 获得锁。若已处于加锁状态,则返回false且不会挂起。
Queue
Queue就像一条读写数据的管道。提供数据的线程在一边写入数据,而读取数据的线程则在另一边读出数据。若Queue中没有可供读取的数据时,读取数据的线程会挂起等待数据的到来。
下面就是一个使用Queue的简单程序。
___FCKpd___6本程序中,一个线程读入一行之后,另一个线程就输出它。若把第3行改成数组,即“q = []”后,线程间失去同步,则程序无法正确运作。
Queue有下列方法。
Queue.new
- 生成新的Queue。
Queue.empty?
- 若Queue为空则返回真。
Queue.push value
- 向Queue添加value。
Queue.pop [non_block]
- 从Queue中取出数据。若参数non_block被指定为非假值而且Queue为空时,则引发错误。其他情况下,若Queue为空时,读取数据的线程会被挂起直到有新数据加入。
例题
让我们来看一看在并行处理编程领域中非常有名的“哲学家就餐”问题。
“哲学家就餐”问题就是指在下述情况下,哲学家如何取得同步的问题。
有N位哲学家围坐在圆桌旁。圆桌中间放着盛满意大利面条的大盘子。另有N把叉子分别放在每位哲学家身旁。哲学家继续思考问题,若觉得饿就会拿起两旁的叉子就餐。吃完后就将叉子放回去。这些哲学家都是绅士,即使很饿也会等到两旁都有叉子可用之后才会就餐。
运行程序后会依次显示当前的状态。各个字符所代表的意义如下。
o:
- 正在思考问题的哲学家
*:- 正在工作的哲学家
-:- 无人使用的叉子
|:- 正被使用的叉子
哲学家思考的时间和就餐的时间由随机数决定。
1 #
2 # The Dining Philosophers - thread example
3 #
4 require "thread"
5
6 N=7 # number of philosophers
7 $forks = []
8 for i in 0..N-1
9 $forks[i] = Mutex.new
10 end
11 $state = "-o"*N
12
13 def wait
14 sleep rand(20)/10.0
15 end
16
17 def think(n)
18 wait();
19 end
20
21 def eat(n)
22 wait();
23 end
24
25 def philosopher(n)
26 while true
27 think n
28 $forks[n].lock
29 if not $forks[(n+1)%N].try_lock
30 $forks[n].unlock # avoid deadlock
31 next
32 end
33 $state[n*2] = ?|;
34 $state[(n+1)%N*2] = ?|;
35 $state[n*2+1] = ?*;
36 print $state, "/n"
37 eat(n)
38 $state[n*2] = ?-;
39 $state[(n+1)%N*2] = ?-;
40 $state[n*2+1] = ?o;
41 print $state, "/n"
42 $forks[n].unlock
43 $forks[(n+1)%N].unlock
44 end
45 end
46
47 for i in 0..N-1
48 Thread.start{philosopher(i)}
49 sleep 0.1
50 end
51 sleep
52 exit
13 end
14 q.push nil # 终止标记
15 th.join
本程序中,一个线程读入一行之后,另一个线程就输出它。若把第3行改成数组,即“q = []”后,线程间失去同步,则程序无法正确运作。
Queue有下列方法。
- 生成新的Queue。
- 若Queue为空则返回真。
- 向Queue添加value。
- 从Queue中取出数据。若参数non_block被指定为非假值而且Queue为空时,则引发错误。其他情况下,若Queue为空时,读取数据的线程会被挂起直到有新数据加入。
Queue.new
Queue.empty?
Queue.push value
Queue.pop [non_block]
例题
让我们来看一看在并行处理编程领域中非常有名的“哲学家就餐”问题。
“哲学家就餐”问题就是指在下述情况下,哲学家如何取得同步的问题。
有N位哲学家围坐在圆桌旁。圆桌中间放着盛满意大利面条的大盘子。另有N把叉子分别放在每位哲学家身旁。哲学家继续思考问题,若觉得饿就会拿起两旁的叉子就餐。吃完后就将叉子放回去。这些哲学家都是绅士,即使很饿也会等到两旁都有叉子可用之后才会就餐。
运行程序后会依次显示当前的状态。各个字符所代表的意义如下。
-
o:
- 正在思考问题的哲学家 *:
- 正在工作的哲学家 -:
- 无人使用的叉子 |:
- 正被使用的叉子
哲学家思考的时间和就餐的时间由随机数决定。
___FCKpd___7