傳統(tǒng)程序有一個(gè)單獨(dú)的線程執(zhí)行，包含該程序的語句或指令順序執(zhí)行直到程序終止。

一個(gè)多線程的程序有多個(gè)線程的執(zhí)行。在每個(gè)線程是按順序執(zhí)行的，但是在多核CPU機(jī)器上線程可能并行地執(zhí)行。例如，通常情況下在單一CPU的機(jī)器，多個(gè)線程實(shí)際上不是并行執(zhí)行的，而是模擬并行交叉的線程的執(zhí)行。

Ruby的可以使用 Thread 類很容易地編寫多線程程序。 Ruby線程是一個(gè)輕量級(jí)的和高效的在代碼中實(shí)現(xiàn)并行性。
創(chuàng)建Ruby線程：

要啟動(dòng)一個(gè)新線程，關(guān)聯(lián)一個(gè)塊通過調(diào)用Thread.new。將創(chuàng)建一個(gè)新的線程執(zhí)行的代碼塊，原始線程將立即從Thread.new返回并繼續(xù)執(zhí)行下一個(gè)語句：

# Thread #1 is running here
Thread.new {
 # Thread #2 runs this code
}
# Thread #1 runs this code

例如：

這里是一個(gè)例子說明，我們?nèi)绾文軌蚶枚嗑€程的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}"

這將產(chǎn)生以下結(jié)果：

Started At Wed May 14 08:21:54 -0700 2008
func1 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:55 -0700 2008
func1 at: Wed May 14 08:21:56 -0700 2008
func2 at: Wed May 14 08:21:56 -0700 2008
func1 at: Wed May 14 08:21:58 -0700 2008
End at Wed May 14 08:22:00 -0700 2008

線程的生命周期：

創(chuàng)建一個(gè)新的線程用 Thread.new。也可以使用了同義詞用 Thread.Start 和 Thread.fork。

沒有必要啟動(dòng)一個(gè)線程在它被創(chuàng)建后，它會(huì)自動(dòng)開始運(yùn)行時(shí)，CPU 資源成為可用。

Thread 類定義了一些方法來查詢和處理的線程在運(yùn)行時(shí)。運(yùn)行一個(gè)線程塊中的代碼調(diào)用Thread.new，然后它停止運(yùn)行。

該塊中的最后一個(gè)表達(dá)式的值是線程的值，可以通過調(diào)用 Thread對(duì)象值的方法。如果線程運(yùn)行完成，則該值為線程的返回值。否則，該值方法會(huì)阻塞不會(huì)返回，直到該線程已完成。
類方法Thread.current返回代表當(dāng)前線程的 Thread對(duì)象。這允許線程操縱自己。類方法 Thread.main返回線程對(duì)象代表主線程，thread.this初始線程開始執(zhí)行Ruby程序開始時(shí)。

可以等待一個(gè)特定的線程通過調(diào)用該線程的Thread.Join方法來完成。調(diào)用線程將被阻塞，直到給定線程完成。
線程和異常：

如果在主線程中引發(fā)一個(gè)異常，并沒有任何地方處理，Ruby解釋器打印一條消息并退出。在主線程以外的其他線程，未處理的異常導(dǎo)致線程停止運(yùn)行。

如果線程 t 退出，因?yàn)槲刺幚淼漠惓?，而另一個(gè)線程調(diào)用t.join或t.value，那么所發(fā)生的異常在 t 中提出的線程 s。

如果 Thread.abort_on_exception 為 false，默認(rèn)情況下，出現(xiàn)未處理的異常只是殺死當(dāng)前線程和所有其余的繼續(xù)運(yùn)行。

如果想在任何線程中的任何未處理的異常導(dǎo)致解釋退出中，設(shè)置類方法Thread.abort_on_exception 為 true。

t = Thread.new { ... }
t.abort_on_exception = true

線程變量：

一個(gè)線程可以正常訪問是在范圍內(nèi)的任何變量的線程被創(chuàng)建時(shí)。一個(gè)線程塊的局部變量是線程的局部，而不是共享。

Thread類提供一個(gè)特殊的功能，允許通過名稱來創(chuàng)建和存取線程局部變量。只需把線程對(duì)象，如果它是一個(gè)Hash，寫入元素使用[] =和讀取他們帶回使用[]。

在這個(gè)例子中，每個(gè)線程記錄計(jì)數(shù)變量的當(dāng)前值與該鍵mycount的一個(gè)threadlocal變量。

#!/usr/bin/ruby

count = 0
arr = []

10.times do |i|
  arr[i] = Thread.new {
   sleep(rand(0)/10.0)
   Thread.current["mycount"] = count
   count += 1
  }
end

arr.each {|t| t.join; print t["mycount"], ", " }
puts "count = #{count}"

這將產(chǎn)生下面的結(jié)果：

8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10

主線程等待子線程完成，然后打印出每個(gè)捕獲count的值。
線程優(yōu)先級(jí)：

影響線程調(diào)度的第一因素，是線程的優(yōu)先級(jí)：高優(yōu)先級(jí)線程之前計(jì)劃的低優(yōu)先級(jí)的線程。更確切地說，一個(gè)線程將只獲得CPU時(shí)間，如果沒有更高優(yōu)先級(jí)的線程等待運(yùn)行。

可以設(shè)置和查詢一個(gè)Ruby線程對(duì)象的優(yōu)先級(jí)=和優(yōu)先級(jí)的優(yōu)先級(jí)。新創(chuàng)建的線程開始在相同的優(yōu)先級(jí)的線程創(chuàng)建它。啟動(dòng)主線程優(yōu)先級(jí)為0。

沒有任何方法設(shè)置線程優(yōu)先級(jí)在開始運(yùn)行前。然而，一個(gè)線程可以提高或降低自己的優(yōu)先級(jí)的第一次操作。
線程排斥：

如果兩個(gè)線程共享訪問相同的數(shù)據(jù)，至少有一個(gè)線程修改數(shù)據(jù)，你必須要特別小心，以確保任何線程都不能看到數(shù)據(jù)處于不一致的狀態(tài)。這稱為線程排除。

Mutex類是一些共享資源的互斥訪問，實(shí)現(xiàn)了一個(gè)簡(jiǎn)單的信號(hào)鎖定。即，只有一個(gè)線程可持有的鎖在給定時(shí)間。其他線程可能選擇排隊(duì)等候的鎖變得可用，或者可以簡(jiǎn)單地選擇立即得到錯(cuò)誤，表示鎖定不可用。

通過將所有訪問共享數(shù)據(jù)的互斥體的控制下，我們確保一致性和原子操作。我們的嘗試?yán)樱谝粋€(gè)無需mutax，第二個(gè)使用mutax：
無需Mutax的例子：

#!/usr/bin/ruby
require 'thread'

count1 = count2 = 0
difference = 0
counter = Thread.new do
  loop do
   count1 += 1
   count2 += 1
  end
end
spy = Thread.new do
  loop do
   difference += (count1 - count2).abs
  end
end
sleep 1
puts "count1 : #{count1}"
puts "count2 : #{count2}"
puts "difference : #{difference}"

這將產(chǎn)生以下結(jié)果：

count1 : 1583766
count2 : 1583766
difference : 637992

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

count1 = count2 = 0
difference = 0
counter = Thread.new do
  loop do
   mutex.synchronize do
     count1 += 1
     count2 += 1
   end
  end
end
spy = Thread.new do
  loop do
    mutex.synchronize do
     difference += (count1 - count2).abs
    end
  end
end
sleep 1
mutex.lock
puts "count1 : #{count1}"
puts "count2 : #{count2}"
puts "difference : #{difference}"

這將產(chǎn)生以下結(jié)果：

count1 : 696591
count2 : 696591
difference : 0

處理死鎖：

當(dāng)我們開始使用互斥對(duì)象的線程排除，我們必須小心地避免死鎖。死鎖的情況發(fā)生時(shí)，所有線程正在等待獲取另一個(gè)線程持有的資源。因?yàn)樗械木€程被阻塞，他們不能釋放其所持有的鎖。因?yàn)樗麄兛梢圆会尫沛i，其它線程不能獲得這些鎖。

一個(gè)條件變量?jī)H僅是一個(gè)信號(hào)，與資源相關(guān)聯(lián)，并用于特定互斥鎖的保護(hù)范圍內(nèi)的。當(dāng)需要一個(gè)資源不可用，等待一個(gè)條件變量。這一行動(dòng)釋放相應(yīng)的互斥鎖。當(dāng)一些其他線程發(fā)送信號(hào)的資源是可用的，原來的線程來等待，并同時(shí)恢復(fù)上的鎖臨界區(qū)。
例子：

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

cv = ConditionVariable.new
a = Thread.new {
  mutex.synchronize {
   puts "A: I have critical section, but will wait for cv"
   cv.wait(mutex)
   puts "A: I have critical section again! I rule!"
  }
}

puts "(Later, back at the ranch...)"

b = Thread.new {
  mutex.synchronize {
   puts "B: Now I am critical, but am done with cv"
   cv.signal
   puts "B: I am still critical, finishing up"
  }
}
a.join
b.join

這將產(chǎn)生以下結(jié)果：

A: I have critical section, but will wait for cv
(Later, back at the ranch...)
B: Now I am critical, but am done with cv
B: I am still critical, finishing up
A: I have critical section again! I rule!

線程狀態(tài)：

有五種可能的返回值對(duì)應(yīng)于下表中所示的5個(gè)可能的狀態(tài)。該的狀態(tài)方法返回的線程狀態(tài)。

 Thread類的方法：

Thread類提供以下方法，它們適用程序的所有線程。這些方法它們使用Thread類的名稱來調(diào)用，如下所示：

Thread.abort_on_exception = true

這里是所有類方法的完整列表：

 線程實(shí)例方法：

這些方法是適用于一個(gè)線程的一個(gè)實(shí)例。這些方法將被調(diào)用，使用一個(gè)線程的一個(gè)實(shí)例如下：

#!/usr/bin/ruby

thr = Thread.new do  # Calling a class method new
  puts "In second thread"
  raise "Raise exception"
end
thr.join  # Calling an instance method join

這里是所有實(shí)例方法的完整列表：