ruby 中的并发并行和全局锁

并发和并行

在开发时,咱们常常会接触到两个概念: 并发和并行,几乎全部谈到并发和并行的文章都会提到一点: 并发并不等于并行.那么如何理解这句话呢?

并发： 厨师同时接收到了2个客人点了的菜单须要处理.
顺序执行： 若是只有一个厨师,那么他只能一个菜单接着一个菜单的去完成.
并行执行： 若是有两个厨师,那么就能够并行,两我的一块儿作菜.

将这个例子扩展到咱们的web开发中， 就能够这样理解：

并发：服务器同时收到了两个客户端发起的请求.
顺序执行：服务器只有一个进程（线程）处理请求,完成了第一个请求才能完成第二个请求,因此第二个请求就须要等待.
并行执行：服务器有两个进程（线程）处理请求,两个请求都能获得响应,而不存在前后的问题.

根据上述所描述的例子,咱们在 ruby 中怎么去模拟出这样的一个并发行为呢? 看下面这一段代码：

• 顺序执行:
  模拟只有一个线程时的操做.

require 'benchmark'

def f1
  puts "sleep 3 seconds in f1\n"
  sleep 3
end

def f2
  puts "sleep 2 seconds in f2\n"
  sleep 2 
end

Benchmark.bm do |b|
  b.report do
    f1
    f2
  end  
end
## 
## user       system     total        real
## sleep 3 seconds in f1
## sleep 2 seconds in f2
## 0.000000   0.000000   0.000000 (  5.009620)

上述代码很简单，用 sleep 模拟耗时的操做.顺序执行时候的消耗时间.

• 并行执行
  模拟多线程时的操做

# 接上述代码
Benchmark.bm do |b|
  b.report do
    threads = []
    threads << Thread.new { f1 }
    threads << Thread.new { f2 }
    threads.each(&:join)
  end  
end
##
## user       system     total        real
## sleep 3 seconds in f1
## sleep 2 seconds in f2
## 0.000000   0.000000   0.000000 (  3.005115)

咱们发现多线程下耗时和f1的耗时相近,这与咱们预期的同样,采用多线程能够实现并行.
Ruby 的多线程可以应付 IO Block，当某个线程处于 IO Block 状态时，其它的线程还能够继续执行，从而使总体处理时间大幅缩短.

Ruby 中的线程

上述的代码示例中使用了 ruby 中 Thread 的线程类, Ruby能够很容易地写Thread类的多线程程序.Ruby线程是一个轻量级的和有效的方式,以实如今你的代码的并行.
接下来来描述一段并发时的情景

def thread_test
    time = Time.now
    threads = 3.times.map do 
      Thread.new do
        sleep 3 
      end
    end
    puts "不用等3秒就能够看到我:#{Time.now - time}"
    threads.map(&:join)
    puts "如今须要等3秒才能够看到我:#{Time.now - time}"
  end
  test
  ## 不用等3秒就能够看到我:8.6e-05
  ## 如今须要等3秒才能够看到我:3.003699

Thread的建立是非阻塞的,因此文字当即就能够输出.这样就模拟了一个并发的行为.每一个线程sleep 3 秒,在阻塞的状况下,多线程能够实现并行.

那么这个时候咱们是否是就完成了并行的能力呢?
很遗憾,我上述的描述中只是提到了咱们在非阻塞的状况下能够模拟了并行.让咱们再看一下别的例子:

require 'benchmark'
def multiple_threads
  count = 0
  threads = 4.times.map do 
    Thread.new do
      2500000.times { count += 1}
    end
  end
  threads.map(&:join)
end

def single_threads
  time = Time.now
  count = 0
  Thread.new do
    10000000.times { count += 1}
  end.join
end

Benchmark.bm do |b|
  b.report { multiple_threads }
  b.report { single_threads }
end
##       user     system      total        real
##   0.600000   0.010000   0.610000 (  0.607230)
##   0.610000   0.000000   0.610000 (  0.623237)

从这里能够看出,即使咱们将同一个任务分红了4个线程并行,可是时间并无减小,这是为何呢？
由于有全局锁(GIL)的存在！！！

全局锁

咱们一般使用的ruby采用了一种称之为GIL的机制.

即使咱们但愿使用多线程来实现代码的并行， 因为这个全局锁的存在， 每次只有一个线程可以执行代码，至于哪一个线程可以执行， 这个取决于底层操做系统的实现。
即使咱们拥有多个CPU， 也只是为每一个线程的执行多提供了几个选择而已。

咱们上面代码中每次只有一个线程能够执行 count += 1 .

Ruby 多线程并不能重复利用多核 CPU，使用多线程后总体所花时间并不缩短，反而因为线程切换的影响，所花时间可能还略有增长。

可是咱们以前sleep的时候， 明明实现了并行啊！

这个就是Ruby设计高级的地方——全部的阻塞操做是能够并行的,包括读写文件,网络请求在内的操做都是能够并行的.

require 'benchmark'
require 'net/http'

# 模拟网络请求
def multiple_threads
  uri = URI("http://www.baidu.com")
  threads = 4.times.map do 
    Thread.new do
      25.times { Net::HTTP.get(uri) }
    end
  end
  threads.map(&:join)
end

def single_threads
  uri = URI("http://www.baidu.com")
  Thread.new do
    100.times { Net::HTTP.get(uri) }
  end.join
end

Benchmark.bm do |b|
  b.report { multiple_threads }
  b.report { single_threads }
end

  user     system      total        real
0.240000   0.110000   0.350000 (  3.659640)
0.270000   0.120000   0.390000 ( 14.167703)

在网络请求时程序发生了阻塞,而这些阻塞在Ruby的运行下是能够并行的,因此在耗时上大大缩短了.

GIL 的思考

那么,既然有了这个GIL锁的存在,是否意味着咱们的代码就是线程安全了呢?
很遗憾不是的,GIL 在ruby 执行中会某一些工做点时切换到另外一个工做线程去,若是共享了一些类变量时就有可能踩坑.

那么, GIL 在 ruby代码的执行中何时会切换到另一个线程去工做呢?

有几个明确的工做点:

• 方法的调用和方法的返回, 在这两个地方都会检查一下当前线程的gil的锁是否超时,是否要调度到另外线程去工做

• 全部io相关的操做, 也会释放gil的锁让其它线程来工做

• 在c扩展的代码中手动释放gil的锁

• 还有一个比较难理解, 就是ruby stack 进入 c stack的时候也会触发gil的检测

一个例子

@a = 1
r = []
10.times do |e|

Thread.new {
   @c = 1
   @c += @a
   r << [e, @c]
}
end
r
## [[3, 2], [1, 2], [2, 2], [0, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [4, 2]]

上述中r 里 虽然e的先后顺序不同, 可是@c的值始终保持为 2 ,即每一个线程时都能保留好当前的 @c 的值.没有线程简的调度.
若是在上述代码线程中加入 可能会触发GIL的操做 例如 puts 打印到屏幕:

@a = 1
r = []
10.times do |e|

Thread.new {
   @c = 1
   puts @c
   @c += @a
   r << [e, @c]
}
end
r
## [[2, 2], [0, 2], [4, 3], [5, 4], [7, 5], [9, 6], [1, 7], [3, 8], [6, 9], [8, 10]]

这个就会触发GIL的lock, 数据异常了.

小结

Web 应用大可能是 IO 密集型的,利用 Ruby 多进程+多线程模型将能大幅提高系统吞吐量.其缘由在于：当Ruby 某个线程处于 IO Block 状态时,其它的线程还能够继续执行,从而下降 IO Block 对总体的影响.但因为存在 Ruby GIL (Global Interpreter Lock),MRI Ruby 并不能真正利用多线程进行并行计算.

PS. 听说 JRuby 去除了GIL,是真正意义的多线程,既能应付 IO Block,也能充分利用多核 CPU 加快总体运算速度,有计划了解一些.