1.介绍Ruby的多线程

Ruby的多线程是用户级多线程，这样使得Ruby的多线程移植非常容易，你并不需关心具体的操作系统；这样做也使线程容易控制，程序不容易产生死锁这类严重的线程问题。
但是同时，由于Ruby的多线程并不是真正意义上的操作系统级多线程，不管代码使用了多少个Thread类的实例，都只会在启动解释器这一个进程内执行，由Ruby解释器进行具体的线程切换管理，其效率要低于由操作系统管理线程的效率，且不能使用多个CPU。
在Ruby中同时做多件事最简单的方式就是使用Thread类，Thread类提供了一种高效和轻量级的手段来同时处理多件任务。
Thread类由Ruby解释器具体实现，提供了一种同时处理多个任务的方法， Thread类实现的并不是操作系统级多线程。
Ruby多线程的优点和缺点同样明显，缺点是效率不如操作系统级多线程，不能使用多个CPU，但其优点也很明显，即可移植性很高。这就需要设计人员综合考虑。

当Ruby程序执行完毕的时候，他会杀掉所有的线程，不管其它的线程的运行状态如何。如果没有使用join方法，那么主程序执行完毕后会把所有没有执行完毕的线程杀掉。
上面的实例程序中，当主程序运行完毕时，两个线程都没有运行结束就被中止掉了。我们可以使用join方法来让主程序等待某个特定线程结束，对每一个线程使用join方法，可以确保在程序结束前所有的线程可以运行完毕。

x = Thread.new { sleep 0.1; print “x”; print “y”; print “z” }
a = Thread.new { print “a”; print “b”; sleep 0.2; print “c” }
x.join
a.join

2.ruby如何进行集成操作？ruby能进行多重集成吗？

Ruby继承的语法很简单，使用 < 即可。
Ruby语言只支持单继承，每一个类都只能有一个直接父类。这样避免了多继承的复杂度。但同时，Ruby提供了mixin的机制可以用来实现多继承。
可以使用super关键字调用对象父类的方法，当super省略参数时，将使用当前方法的参数来进行调用。

3.ruby的特点

归纳起来，Ruby有以下优点：
?解释型执行，方便快捷
Ruby是解释型语言，其程序无需编译即可执行。
?语法简单、优雅
语法比较简单，类似Algol系语法。
?完全面向对象
Ruby从一开始就被设计成纯粹的面向对象语言，因此所有东西都是对象，例如整数等基本数据类型。
?内置正则式引擎，适合文本处理
Ruby支持功能强大的字符串操作和正则表达式检索功能，可以方便的对字符串进行处理。
?自动垃圾收集
具有垃圾回收（Garbage Collect，GC）功能，能自动回收不再使用的对象。不需要用户对内存进行管理。
?跨平台和高度可移植性
Ruby支持多种平台，在Windows, Unix, Linux, MacOS上都可以运行。Ruby程序的可移植性非常好，绝大多数程序可以不加修改的在各种平台上加以运行。
?有优雅、完善的异常处理机制
Ruby提供了一整套异常处理机制，可以方便优雅地处理代码处理出错的情况。
?拥有很多高级特性
Ruby拥有很多高级特性，例如操作符重载、Mix-ins、特殊方法等等，是用这些特性可以方便地完成各种强大的功能。

同时，由于是解释型语言，Ruby也有下列缺点：
?解释型语言，所以速度较慢
?静态检查比较少

4.解释下ruby的特殊方法和特殊类

特殊方法是指某实例所特有的方法。一个对象有哪些行为由对向所属的类决定，但是有时候，一些特殊的对象有何其他对象不一样的行为，在多数程序设计语言中，例如C++和Java，我们必须定义一个新类，但在Ruby中，我们可以定义只从属于某个特定对象的方法，这种方法我们成为特殊方法(Singleton Method)。

class SingletonTest
  def info
   puts “This is This is SingletonTest method”
  end
end

obj1 = SingletonTest.new
obj2 = SingletonTest.new

def obj2.info
  puts “This is obj2″
end

obj1.info
obj2.info

 执行结果为：
This is This is SingletonTest method
This is obj2

有时候，我们需要给一个对象定义一系列的特殊方法，如果按照前面的方法，那么只能一个一个定义：

def obj2.singleton_method1
end

def obj2.singleton_method2
end

def obj2.singleton_method3
end
……
def obj2.singleton_methodn
end

这样做非常繁复麻烦，而且无法给出一个统一的概念模型，因此Ruby提供了另外一种方法，
class << obj
……
end

obj是一个具体的对象实例，class << 代表它的特殊类。

class SingletonTest
  def meth1
   puts “This is meth1″
  end

  def meth2
   puts “This is meth2″
  end
end

obj1 = SingletonTest.new
obj2 = SingletonTest.new

class << obj2
  def meth1
   puts “This is obj2′s meth1″
  end
 
  def meth2
   puts “This is obj2′s meth2″
  end
end

obj1.meth1
obj1.meth2
obj2.meth1
obj2.meth2

执行结果为：
This is meth1
This is meth2
This is obj2′s meth1
This is obj2′s meth2

5.ruby如何实现动态方法调用

在Ruby中，有多种方法可以实现方法的动态调用。
1. 使用send方法
第一种实现动态方法调用是使用send方法，send方法在Object类中定义，方法的第一个参数是一个符号用来表示所要调用的方法，后面则是所调用方法需要的参数。
“This is a dog1″.send(:length) => 14
上面的代码中通过send方法去对一个字符串执行length操作，返回字符串的长度。

class TestClass
 def hello(*args)
  ”Hello ” + args.join(‘ ‘)
 end
end

a = TestClass.new
puts a.send :hello, “This”, “is”, “a”, “dog!”

执行结果为：
Hello This is a dog!

2. 使用Method类和UnboundMethod类
另一种实现动态方法调用是使用Object类的method方法，这个方法返回一个Method类的对象。我们可以使用call方法来执行方法调用。
test1 = “This is a dog1″.method(:length)
test1.call  => 14

class Test
 def initialize(var)
  @var = var
 end
 
 def hello()
  ”Hello, @var = #{@var}”
 end
end

k = Test.new(10)
m = k.method(:hello)
m.call   #=> “Hello, @iv = 99″

l = Test.new(‘Grant’)
m = l.method(“hello”)
m.call   #=> “Hello, @iv = Fred”

可以在使用对象的任何地方使用method对象，当调用call方法时，参数所指明的方法会被执行，这种行为有些像Ｃ语言中的函数指针。你也可以把method对象作为一个迭代器使用。
def square(a)
 a*a
end

mObj = method(:square)
[1, 2, 3, 4].collect(&mObj)  => [1 4 9 16]

Method对象都是和某一特定对象绑定的，也就是说你需要通过某一对象使用Method对象。你也可以通过UnboundMethod类创建对象，然后再把它绑定到某个具体的对象中。如果UnboundMethod对象调用时尚未绑定，则会引发异常。
class Double
 def get_value
  2 * @side
 end
 
  def initialize(side)
   @side = side
  end
end

a = Double.instance_method(:get_value) #返回一个UnboundMethod对象
s = Double.new(50)
b = a.bind(s)
puts b.call

执行结果为：
100

看下面一个更具体的例子：
class CommandInterpreter
def do_2() print “This is 2
”; end
 def do_1() print “This is 1
”; end
 def do_4() print “This is 4
”; end
 def do_3() print “This is 3
”; end
  
 Dispatcher = {
   ?2 => instance_method(:do_2),
   ?1 => instance_method(:do_1),
   ?4 => instance_method(:do_4),
   ?3 => instance_method(:do_3)
 }

 def interpret(string)
   string.each_byte {|i| Dispatcher[i].bind(self).call }
  end
end

interpreter = CommandInterpreter.new
interpreter.interpret(’1234′)

执行结果为：
This is 1
This is 2
This is 3
This is 4

3. 使用eval方法
我们还可以使用eval方法实现方法动态调用。eval方法在Kernel模块中定义，有多种变体如class_eval，module_eval，instance_eval等。Eval方法将分析其后的字符串参数并把这个字符串参数作为Ruby代码执行。
str = “Hello”
eval “str + ‘ World!’” => Hello World!

sentence = %q{“This is a test!”.length}
eval sentence => 15
当我们在使用eval方法时，我们可以通过eval方法的第二个参数指明eval所运行代码的上下文环境，这个参数可以是Binding类对象或Proc类对象。Binding类封装了代码在某一环境运行的上下文，可以供以后使用。
class BindingTest
 def initialize(n)
   @value = http://www.mamicode.com/n
 end

 def getBinding
   return binding() #使用Kernel#binding方法返回一个Binding对象
  end
end

obj1 = BindingTest.new(10)
binding1 = obj1.getBinding
obj2 = BindingTest.new(“Binding Test”)
binding2 = obj2.getBinding

puts eval(“@value”, binding1)  #=> 10
puts eval(“@value”, binding2)  #=> Binding Test
puts eval(“@value”)     #=> nil

可以看到上述代码中，@value在binding1所指明的上下文环境中值为10，在binding2所指明的上下文环境中值为Binding Test。当eval方法不提供binding参数时，在当前上下文环境中@value并未定义，值为nil。

[汇]Ruby知识点（一）