传统程序有一个单独的线程执行，包含该程序的语句或指令顺序执行直到程序终止。
一个多线程的程序有多个线程的执行。在每个线程是按顺序执行的，但是在多核CPU机器上线程可能并行地执行。例如，通常情况下在单一CPU的机器，多个线程实际上不是并行执行的，而是模拟并行交叉的线程的执行。
Ruby的可以使用 Thread 类很容易地编写多线程程序。 Ruby线程是一个轻量级的和高效的在代码中实现并行性。
创建Ruby线程：
要启动一个新线程，关联一个块通过调用Thread.new。将创建一个新的线程执行的代码块，原始线程将立即从Thread.new返回并继续执行下一个语句：
# Thread #1 is running here
Thread.new {
# Thread #2 runs this code
}
# Thread #1 runs this code
例如：
这里是一个例子说明，我们如何能够利用多线程的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}"
这将产生以下结果：
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
线程的生命周期：
创建一个新的线程用 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。
t = Thread.new { ... }
t.abort_on_exception = true
线程变量：
一个线程可以正常访问是在范围内的任何变量的线程被创建时。一个线程块的局部变量是线程的局部，而不是共享。
Thread类提供一个特殊的功能，允许通过名称来创建和存取线程局部变量。只需把线程对象，如果它是一个Hash，写入元素使用[] =和读取他们带回使用[]。
在这个例子中，每个线程记录计数变量的当前值与该键mycount的一个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}"
这将产生下面的结果：
8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10
主线程等待子线程完成，然后打印出每个捕获count的值。
线程优先级：
影响线程调度的第一因素，是线程的优先级：高优先级线程之前计划的低优先级的线程。更确切地说，一个线程将只获得CPU时间，如果没有更高优先级的线程等待运行。
可以设置和查询一个Ruby线程对象的优先级=和优先级的优先级。新创建的线程开始在相同的优先级的线程创建它。启动主线程优先级为0。
没有任何方法设置线程优先级在开始运行前。然而，一个线程可以提高或降低自己的优先级的第一次操作。
线程排斥：
如果两个线程共享访问相同的数据，至少有一个线程修改数据，你必须要特别小心，以确保任何线程都不能看到数据处于不一致的状态。这称为线程排除。
Mutex类是一些共享资源的互斥访问，实现了一个简单的信号锁定。即，只有一个线程可持有的锁在给定时间。其他线程可能选择排队等候的锁变得可用，或者可以简单地选择立即得到错误，表示锁定不可用。
通过将所有访问共享数据的互斥体的控制下，我们确保一致性和原子操作。我们的尝试例子，第一个无需mutax，第二个使用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}"
这将产生以下结果：
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}"
这将产生以下结果：
count1 : 696591 count2 : 696591 difference : 0
处理死锁：
当我们开始使用互斥对象的线程排除，我们必须小心地避免死锁。死锁的情况发生时，所有线程正在等待获取另一个线程持有的资源。因为所有的线程被阻塞，他们不能释放其所持有的锁。因为他们可以不释放锁，其它线程不能获得这些锁。
一个条件变量仅仅是一个信号，与资源相关联，并用于特定互斥锁的保护范围内的。当需要一个资源不可用，等待一个条件变量。这一行动释放相应的互斥锁。当一些其他线程发送信号的资源是可用的，原来的线程来等待，并同时恢复上的锁临界区。
例子：
#!/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
这将产生以下结果：
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!
线程状态：
有五种可能的返回值对应于下表中所示的5个可能的状态。该的状态方法返回的线程状态。
Thread类的方法：
Thread类提供以下方法，它们适用程序的所有线程。这些方法它们使用Thread类的名称来调用，如下所示：
Thread.abort_on_exception = true
这里是所有类方法的完整列表：
线程实例方法：
这些方法是适用于一个线程的一个实例。这些方法将被调用，使用一个线程的一个实例如下：
#!/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
这里是所有实例方法的完整列表：
以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索ruby
c语言多线程编程入门、多线程编程入门、ruby语言入门、ruby入门、ruby从入门到精通，以便于您获取更多的相关知识。