Ruby on Rails 入门之：(19) ruby线程同步控制

在Ruby中，提供三种实现同步的方式，分别是：

1. 通过Mutex类实现线程同步

2. 监管数据交接的Queue类实现线程同步

3. 使用ConditionVariable实现同步控制

1. 通过Mutex类实现线程同步

通过Mutex类实现线程同步控制，如果在多个线程钟同时需要一个程序变量，可以将这个变量部分使用lock锁定。

代码如下：

[ruby]  view plain copy

1. #encoding:gbk  
2. require "thread"  
3. puts "Synchronize Thread"  
4.   
5. @num=200  
6. @mutex=Mutex.new  
7.   
8. def buyTicket(num)  
9.     @mutex.lock  
10.         if @num>=num  
11.             @num=@num-num  
12.             puts "you have successfully bought #{num} tickets"  
13.         else  
14.             puts "sorry,no enough tickets"  
15.         end  
16.     @mutex.unlock  
17. end  
18.   
19. ticket1=Thread.new 10 do  
20.     10.times do |value|  
21.     ticketNum=15  
22.     buyTicket(ticketNum)  
23.     sleep 0.01  
24.     end  
25. end  
26.   
27. ticket2=Thread.new 10 do  
28.     10.times do |value|  
29.     ticketNum=20  
30.     buyTicket(ticketNum)  
31.     sleep 0.01  
32.     end  
33. end  
34.   
35. sleep 1  
36. ticket1.join  
37. ticket2.join  

程序运行的输出：

[ruby]  view plain copy

1. Synchronize Thread  
2. you have successfully bought 15 tickets  
3. you have successfully bought 20 tickets  
4. you have successfully bought 15 tickets  
5. you have successfully bought 20 tickets  
6. you have successfully bought 15 tickets  
7. you have successfully bought 20 tickets  
8. you have successfully bought 15 tickets  
9. you have successfully bought 20 tickets  
10. you have successfully bought 15 tickets  
11. you have successfully bought 20 tickets  
12. you have successfully bought 15 tickets  
13. sorry,no enough tickets  
14. sorry,no enough tickets  
15. sorry,no enough tickets  
16. sorry,no enough tickets  
17. sorry,no enough tickets  
18. sorry,no enough tickets  
19. sorry,no enough tickets  
20. sorry,no enough tickets  
21. sorry,no enough tickets  

除了使用lock锁定变量，还可以使用try_lock锁定变量，还可以使用Mutex.synchronize同步对某一个变量的访问。

2. 监管数据交接的Queue类实现线程同步

Queue类就是表示一个支持线程的队列，能够同步对队列末尾进行访问。不同的线程可以使用统一个对类，但是不用担心这个队列中的数据是否能够同步，另外使用SizedQueue类能够限制队列的长度

SizedQueue类能够非常便捷的帮助我们开发线程同步的应用程序，应为只要加入到这个队列中，就不用关心线程的同步问题。

经典的生产者消费者问题：

[ruby]  view plain copy

1. #encoding:gbk  
2. require "thread"  
3. puts "SizedQuee Test"  
4.   
5. queue = Queue.new  
6.   
7. producer = Thread.new do  
8.     10.times do |i|  
9.         sleep rand(i) # 让线程睡眠一段时间  
10.         queue << i  
11.         puts "#{i} produced"  
12.     end  
13. end  
14.   
15. consumer = Thread.new do  
16.     10.times do |i|  
17.         value = queue.pop  
18.         sleep rand(i/2)  
19.         puts "consumed #{value}"  
20.     end  
21. end  
22.   
23. consumer.join  

程序的输出：

[ruby]  view plain copy

1. SizedQuee Test  
2. 0 produced  
3. 1 produced  
4. consumed 0  
5. 2 produced  
6. consumed 1  
7. consumed 2  
8. 3 produced  
9. consumed 34 produced  
10.   
11. consumed 4  
12. 5 produced  
13. consumed 5  
14. 6 produced  
15. consumed 6  
16. 7 produced  
17. consumed 7  
18. 8 produced  
19. 9 produced  
20. consumed 8  
21. consumed 9  

3. 使用ConditionVariable实现同步控制

使用 ConditonVariable进行同步控制，能够在一些致命的资源竞争部分挂起线程直到有可用的资源为止。

[ruby]  view plain copy

1. #encoding:gbk  
2. require "thread"  
3. puts "thread synchronize by ConditionVariable"  
4.   
5. mutex = Mutex.new  
6. resource = ConditionVariable.new  
7.   
8. a = Thread.new {  
9.     mutex.synchronize {  
10.         # 这个线程目前需要resource这个资源  
11.         resource.wait(mutex)   
12.         puts "get resource"  
13.     }  
14. }  
15.   
16. b = Thread.new {  
17.     mutex.synchronize {  
18.         #线程b完成对resourece资源的使用并释放resource  
19.         resource.signal  
20.     }  
21. }  
22.   
23. a.join  
24. puts "complete"  

mutex 是声明的一个资源，然后通过ConditionVariable来控制申请和释放这个资源。

b 线程完成了某些工作之后释放资源resource.signal,这样a线程就可以获得一个mutex资源然后进行执行。

执行结果：

[html]  view plain copy

1. thread synchronize by ConditionVariable  
2. get resource  
3. complete