每個正在系統(tǒng)上運行的程序都是一個進(jìn)程。每個進(jìn)程包含一到多個線程。
線程是程序中一個單一的順序控制流程，在單個程序中同時運行多個線程完成不同的工作,稱為多線程。
Ruby 中我們可以通過 Thread 類來創(chuàng)建多線程，Ruby的線程是一個輕量級的，可以以高效的方式來實現(xiàn)并行的代碼。
創(chuàng)建 Ruby 線程
要啟動一個新的線程，只需要調(diào)用 Thread.new 即可:
# 線程 #1 代碼部分
Thread.new {
# 線程 #2 執(zhí)行代碼
}
# 線程 #1 執(zhí)行代碼
實例
以下實例展示了如何在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}"
以上代碼執(zhí)行結(jié)果為：
Started At Wed May 14 08:21:54 -0700 2014
func1 at: Wed May 14 08:21:54 -0700 2014
func2 at: Wed May 14 08:21:54 -0700 2014
func2 at: Wed May 14 08:21:55 -0700 2014
func1 at: Wed May 14 08:21:56 -0700 2014
func2 at: Wed May 14 08:21:56 -0700 2014
func1 at: Wed May 14 08:21:58 -0700 2014
End at Wed May 14 08:22:00 -0700 2014
線程生命周期
1、線程的創(chuàng)建可以使用Thread.new,同樣可以以同樣的語法使用Thread.start 或者Thread.fork這三個方法來創(chuàng)建線程。
2、創(chuàng)建線程后無需啟動，線程會自動執(zhí)行。
3、Thread 類定義了一些方法來操控線程。線程執(zhí)行Thread.new中的代碼塊。
4、線程代碼塊中最后一個語句是線程的值，可以通過線程的方法來調(diào)用，如果線程執(zhí)行完畢，則返回線程值，否則不返回值直到線程執(zhí)行完畢。
5、Thread.current 方法返回表示當(dāng)前線程的對象。 Thread.main 方法返回主線程。
6、通過 Thread.Join 方法來執(zhí)行線程，這個方法會掛起主線程，直到當(dāng)前線程執(zhí)行完畢。
線程狀態(tài)
線程有5種狀態(tài)：
線程和異常
當(dāng)某線程發(fā)生異常，且沒有被rescue捕捉到時，該線程通常會被無警告地終止。但是，若有其它線程因為Thread#join的關(guān)系一直等待該線程的話，則等待的線程同樣會被引發(fā)相同的異常。
begin
t = Thread.new do
Thread.pass # 主線程確實在等join
raise "unhandled exception"
end
t.join
rescue
p $! # => "unhandled exception"
end
使用下列3個方法，就可以讓解釋器在某個線程因異常而終止時中斷運行。
- 啟動腳本時指定-d選項，并以調(diào)試模時運行。
- 用Thread.abort_on_exception設(shè)置標(biāo)志。
- 使用Thread#abort_on_exception對指定的線程設(shè)定標(biāo)志。
當(dāng)使用上述3種方法之一后，整個解釋器就會被中斷。
t = Thread.new { ... }
t.abort_on_exception = true
線程同步控制
在Ruby中，提供三種實現(xiàn)同步的方式，分別是：
1. 通過Mutex類實現(xiàn)線程同步
2. 監(jiān)管數(shù)據(jù)交接的Queue類實現(xiàn)線程同步
3. 使用ConditionVariable實現(xiàn)同步控制
通過Mutex類實現(xiàn)線程同步
通過Mutex類實現(xiàn)線程同步控制，如果在多個線程鐘同時需要一個程序變量，可以將這個變量部分使用lock鎖定。 代碼如下：
#encoding:gbk
require "thread"
puts "Synchronize Thread"
@num=200
@mutex=Mutex.new
def buyTicket(num)
@mutex.lock
if @num>=num
@num=@num-num
puts "you have successfully bought #{num} tickets"
else
puts "sorry,no enough tickets"
end
@mutex.unlock
end
ticket1=Thread.new 10 do
10.times do |value|
ticketNum=15
buyTicket(ticketNum)
sleep 0.01
end
end
ticket2=Thread.new 10 do
10.times do |value|
ticketNum=20
buyTicket(ticketNum)
sleep 0.01
end
end
sleep 1
ticket1.join
ticket2.join
輸出結(jié)果如下：
Synchronize Thread
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
除了使用lock鎖定變量，還可以使用try_lock鎖定變量，還可以使用Mutex.synchronize同步對某一個變量的訪問。
監(jiān)管數(shù)據(jù)交接的Queue類實現(xiàn)線程同步
Queue類就是表示一個支持線程的隊列，能夠同步對隊列末尾進(jìn)行訪問。不同的線程可以使用統(tǒng)一個對類，但是不用擔(dān)心這個隊列中的數(shù)據(jù)是否能夠同步，另外使用SizedQueue類能夠限制隊列的長度
SizedQueue類能夠非常便捷的幫助我們開發(fā)線程同步的應(yīng)用程序，應(yīng)為只要加入到這個隊列中，就不用關(guān)心線程的同步問題。
經(jīng)典的生產(chǎn)者消費者問題：
#encoding:gbk
require "thread"
puts "SizedQuee Test"
queue = Queue.new
producer = Thread.new do
10.times do |i|
sleep rand(i) # 讓線程睡眠一段時間
queue i
puts "#{i} produced"
end
end
consumer = Thread.new do
10.times do |i|
value = queue.pop
sleep rand(i/2)
puts "consumed #{value}"
end
end
consumer.join
程序的輸出：
SizedQuee Test
0 produced
1 produced
consumed 0
2 produced
consumed 1
consumed 2
3 produced
consumed 34 produced
consumed 4
5 produced
consumed 5
6 produced
consumed 6
7 produced
consumed 7
8 produced
9 produced
consumed 8
consumed 9
使用ConditionVariable實現(xiàn)同步控制
使用 ConditonVariable進(jìn)行同步控制，能夠在一些致命的資源競爭部分掛起線程直到有可用的資源為止。
#encoding:gbk
require "thread"
puts "thread synchronize by ConditionVariable"
mutex = Mutex.new
resource = ConditionVariable.new
a = Thread.new {
mutex.synchronize {
# 這個線程目前需要resource這個資源
resource.wait(mutex)
puts "get resource"
}
}
b = Thread.new {
mutex.synchronize {
#線程b完成對resourece資源的使用并釋放resource
resource.signal
}
}
a.join
puts "complete"
mutex 是聲明的一個資源，然后通過ConditionVariable來控制申請和釋放這個資源。
b 線程完成了某些工作之后釋放資源resource.signal,這樣a線程就可以獲得一個mutex資源然后進(jìn)行執(zhí)行。 執(zhí)行結(jié)果：
thread synchronize by ConditionVariable
get resource
complete
線程類方法
完整的 Thread（線程） 類方法如下：
線程實例化方法
以下實例調(diào)用了線程實例化方法 join：
#!/usr/bin/ruby
thr = Thread.new do # 實例化
puts "In second thread"
raise "Raise exception"
end
thr.join # 調(diào)用實例化方法 join
以下是完整實例化方法列表：
線程實例化方法
以下實例調(diào)用了線程實例化方法 join：
#!/usr/bin/ruby
thr = Thread.new do # 實例化
puts "In second thread"
raise "Raise exception"
end
thr.join # 調(diào)用實例化方法 join
以下是完整實例化方法列表：
您可能感興趣的文章:- 使用Ruby來處理JSON的簡單教程
- 使用Ruby編寫發(fā)送郵件的程序的簡單教程
- 在Ruby中利用Net::SMTP類發(fā)送電子郵件的教程
