传统程序有一个单独的线程执行，包含该程序的语句或指令顺序执行直到程序终止。
一个多线程的程序有多个线程的执行。在每个线程是按顺序执行的，但是在多核CPU机器上线程可能并行地执行。例如，通常情况下在单一CPU的机器，多个线程实际上不是并行执行的，而是模拟并行交叉的线程的执行。
Ruby的可以使用 Thread 类很容易地编写多线程程序。 Ruby线程是一个轻量级的和高效的在代码中实现并行性。
创建Ruby线程：
要启动一个新线程，关联一个块通过调用Thread.new。将创建一个新的线程执行的代码块，原始线程将立即从Thread.new返回并继续执行下一个语句：
|
1
2
3
4
5
|
# Thread #1 is running hereThread.new { # Thread #2 runs this code}# Thread #1 runs this code |
例如：
这里是一个例子说明，我们如何能够利用多线程的Ruby的程序。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
#!/usr/bin/rubydef func1 i=0 while i<=2 puts "func1 at: #{Time.now}" sleep(2) i=i+1 endenddef func2 j=0 while j<=2 puts "func2 at: #{Time.now}" sleep(1) j=j+1 endendputs "Started At #{Time.now}"t1=Thread.new{func1()}t2=Thread.new{func2()}t1.joint2.joinputs "End at #{Time.now}" |
这将产生以下结果：
|
1
2
3
4
5
6
7
8
|
Started At Wed May 14 08:21:54 -0700 2008func1 at: Wed May 14 08:21:54 -0700 2008func2 at: Wed May 14 08:21:54 -0700 2008func2 at: Wed May 14 08:21:55 -0700 2008func1 at: Wed May 14 08:21:56 -0700 2008func2 at: Wed May 14 08:21:56 -0700 2008func1 at: Wed May 14 08:21:58 -0700 2008End at Wed May 14 08:22:00 -0700 2008 |
线程的生命周期：
创建一个新的线程用 Thread.new。也可以使用了同义词用 Thread.Start 和 Thread.fork。
没有必要启动一个线程在它被创建后，它会自动开始运行时，CPU 资源成为可用。
Thread 类定义了一些方法来查询和处理的线程在运行时。运行一个线程块中的代码调用Thread.new，然后它停止运行。
该块中的最后一个表达式的值是线程的值，可以通过调用 Thread对象值的方法。如果线程运行完成，则该值为线程的返回值。否则，该值方法会阻塞不会返回，直到该线程已完成。
类方法Thread.current返回代表当前线程的 Thread对象。这允许线程操纵自己。类方法 Thread.main返回线程对象代表主线程，thread.this初始线程开始执行Ruby程序开始时。
可以等待一个特定的线程通过调用该线程的Thread.Join方法来完成。调用线程将被阻塞，直到给定线程完成。
线程和异常：
如果在主线程中引发一个异常，并没有任何地方处理，Ruby解释器打印一条消息并退出。在主线程以外的其他线程，未处理的异常导致线程停止运行。
如果线程 t 退出，因为未处理的异常，而另一个线程调用t.join或t.value，那么所发生的异常在 t 中提出的线程 s。
如果 Thread.abort_on_exception 为 false，默认情况下，出现未处理的异常只是杀死当前线程和所有其余的继续运行。
如果想在任何线程中的任何未处理的异常导致解释退出中，设置类方法Thread.abort_on_exception 为 true。
|
1
2
|
t = Thread.new { ... }t.abort_on_exception = true |
线程变量：
一个线程可以正常访问是在范围内的任何变量的线程被创建时。一个线程块的局部变量是线程的局部，而不是共享。
Thread类提供一个特殊的功能，允许通过名称来创建和存取线程局部变量。只需把线程对象，如果它是一个Hash，写入元素使用[] =和读取他们带回使用[]。
在这个例子中，每个线程记录计数变量的当前值与该键mycount的一个threadlocal变量。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/usr/bin/rubycount = 0arr = []10.times do |i| arr[i] = Thread.new { sleep(rand(0)/10.0) Thread.current["mycount"] = count count += 1 }endarr.each {|t| t.join; print t["mycount"], ", " }puts "count = #{count}" |
这将产生下面的结果：
|
1
|
8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10 |
主线程等待子线程完成，然后打印出每个捕获count的值。
线程优先级：
影响线程调度的第一因素，是线程的优先级：高优先级线程之前计划的低优先级的线程。更确切地说，一个线程将只获得CPU时间，如果没有更高优先级的线程等待运行。
可以设置和查询一个Ruby线程对象的优先级=和优先级的优先级。新创建的线程开始在相同的优先级的线程创建它。启动主线程优先级为0。
没有任何方法设置线程优先级在开始运行前。然而，一个线程可以提高或降低自己的优先级的第一次操作。
线程排斥：
如果两个线程共享访问相同的数据，至少有一个线程修改数据，你必须要特别小心，以确保任何线程都不能看到数据处于不一致的状态。这称为线程排除。
Mutex类是一些共享资源的互斥访问，实现了一个简单的信号锁定。即，只有一个线程可持有的锁在给定时间。其他线程可能选择排队等候的锁变得可用，或者可以简单地选择立即得到错误，表示锁定不可用。
通过将所有访问共享数据的互斥体的控制下，我们确保一致性和原子操作。我们的尝试例子，第一个无需mutax，第二个使用mutax：
无需Mutax的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#!/usr/bin/rubyrequire 'thread'count1 = count2 = 0difference = 0counter = Thread.new do loop do count1 += 1 count2 += 1 endendspy = Thread.new do loop do difference += (count1 - count2).abs endendsleep 1puts "count1 : #{count1}"puts "count2 : #{count2}"puts "difference : #{difference}" |
这将产生以下结果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
count1 : 1583766count2 : 1583766difference : 637992#!/usr/bin/rubyrequire 'thread'mutex = Mutex.newcount1 = count2 = 0difference = 0counter = Thread.new do loop do mutex.synchronize do count1 += 1 count2 += 1 end endendspy = Thread.new do loop do mutex.synchronize do difference += (count1 - count2).abs end endendsleep 1mutex.lockputs "count1 : #{count1}"puts "count2 : #{count2}"puts "difference : #{difference}" |
这将产生以下结果：
|
1
2
3
|
count1 : 696591count2 : 696591difference : 0 |
处理死锁：
当我们开始使用互斥对象的线程排除，我们必须小心地避免死锁。死锁的情况发生时，所有线程正在等待获取另一个线程持有的资源。因为所有的线程被阻塞，他们不能释放其所持有的锁。因为他们可以不释放锁，其它线程不能获得这些锁。
一个条件变量仅仅是一个信号，与资源相关联，并用于特定互斥锁的保护范围内的。当需要一个资源不可用，等待一个条件变量。这一行动释放相应的互斥锁。当一些其他线程发送信号的资源是可用的，原来的线程来等待，并同时恢复上的锁临界区。
例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
#!/usr/bin/rubyrequire 'thread'mutex = Mutex.newcv = ConditionVariable.newa = 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.joinb.join |
这将产生以下结果：
|
1
2
3
4
5
|
A: I have critical section, but will wait for cv(Later, back at the ranch...)B: Now I am critical, but am done with cvB: I am still critical, finishing upA: I have critical section again! I rule! |
线程状态：
有五种可能的返回值对应于下表中所示的5个可能的状态。该的状态方法返回的线程状态。
Thread类的方法：
Thread类提供以下方法，它们适用程序的所有线程。这些方法它们使用Thread类的名称来调用，如下所示：
|
1
|
Thread.abort_on_exception = true |
这里是所有类方法的完整列表：
线程实例方法：
这些方法是适用于一个线程的一个实例。这些方法将被调用，使用一个线程的一个实例如下：
|
1
2
3
4
5
6
7
|
#!/usr/bin/rubythr = Thread.new do # Calling a class method new puts "In second thread" raise "Raise exception"endthr.join # Calling an instance method join |
这里是所有实例方法的完整列表：
