Ruby多线程编程 新手教程

　　下面是小编给大家分享的一篇ruby.html" target="_blank">Ruby多线程编程 新手教程，感兴趣的朋友跟小编一起来了解一下吧!

　　传统程序有一个单独的线程执行，包含该程序的语句或指令顺序执行直到程序终止。

　　一个多线程的程序有多个线程的执行。在每个线程是按顺序执行的，但是在多核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

　　puts "func1 at: #{Time.now}"

　　sleep(2)

　　i=i+1

　　end

　　end

　　def func2

　　j=0

　　while j

　　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多线程编程 新手教程了，想必都了解了吧，更多相关内容请继续关注爱站技术频道。