Ruby同步:如何使线程以正确的顺序一个接一个地工作?

我的问题是我不知道如何使用Ruby同步多个线程.任务是创建六个线程并立即启动它们.所有这些都应该按照我需要它的顺序一个接一个地做一些工作(例如把“线程1”嗨“).

我曾尝试使用Mutex,Monitor和Condition Variable,但所有这些都是按随机顺序工作的.任何人都可以解释如何实现我的目标吗?

经过一段时间与Mutex和条件变量的斗争,我已经实现了我的目标.
这段代码有点乱,我故意不使用循环来“更清晰地看”.

cv = ConditionVariable.new
mutex = Mutex.new

mutex2 = Mutex.new
cv2 = ConditionVariable.new

mutex3 = Mutex.new
cv3 = ConditionVariable.new

mutex4 = Mutex.new
cv4 = ConditionVariable.new

mutex5 = Mutex.new
cv5 = ConditionVariable.new

mutex6 = Mutex.new
cv6 = ConditionVariable.new



Thread.new do
  mutex.synchronize {
    puts 'First: Hi'
    cv.wait(mutex)
    puts 'First: Bye'
    #cv.wait(mutex)
    cv.signal
    puts 'First: One more time'
  }

end

Thread.new do
  mutex.synchronize {
    puts 'Second: Hi'
    cv.signal
    cv.wait(mutex)
    puts 'Second:Bye'
    cv.signal
  }

  mutex2.synchronize {
    puts  'Second: Starting third'
    cv2.signal

  }
end

Thread.new do
  mutex2.synchronize {
    cv2.wait(mutex2)
    puts 'Third: Hi'
  }

  mutex3.synchronize {
    puts 'Third: Starting forth'
    cv3.signal
  }
end

Thread.new do
  mutex3.synchronize {
    cv3.wait(mutex3)
    puts 'Forth: Hi'
  }

  mutex4.synchronize {
    puts 'Forth: Starting fifth'
    cv4.signal
  }
end

Thread.new do
  mutex4.synchronize {
    cv4.wait(mutex4)
    puts 'Fifth: Hi'
  }

  mutex5.synchronize {
    puts 'Fifth: Starting sixth'
    cv5.signal
  }
end

Thread.new {
  mutex5.synchronize {
    cv5.wait(mutex5)
    puts 'Sixth:Hi'
  }
}

sleep 2
最佳答案
使用队列作为PV信号量

您可以滥用Queue,像传统的PV Semaphore一样使用它.为此,您需要创建一个Queue实例:

require 'thread'
...
sem = Queue.new

当一个线程需要等待时,它会调用Queue#deq

# waiting thread
sem.deq

当其他一些线程想要解除阻塞等待线程时,它会将某些东西(任何东西)推送到队列中:

# another thread that wants to unblock the waiting thread
sem.enq :go

工人阶级

这是一个使用Queue同步其开始和结束的worker类:

class Worker

  def initialize(worker_number)  
    @start = Queue.new
    Thread.new do
      @start.deq
      puts "Thread #{worker_number}"
      @when_done.call
    end
  end

  def start
    @start.enq :start
  end

  def when_done(&block)
    @when_done = block
  end

end

构造时,工作者创建一个线程,然后该线程在@start队列上等待.直到#start被调用,线程才会解锁.

完成后,线程将执行调用#when_done的块.我们将在短时间内看到它是如何使用的.

创造工人

首先,让我们确保如果任何线程引发异常,我们就会发现它:

Thread.abort_on_exception = true

我们需要六个工人:

workers = (1..6).map { |i| Worker.new(i) }

告诉每个工人完成后该做什么

这是#when_done发挥作用的地方:

workers.each_cons(2) do |w1, w2|
  w1.when_done { w2.start }
end

这依次需要每一对工人.除了最后一个工作人员之外,每个工人都被告知,当它完成时,它应该在它之后启动工人.那就是最后一个工人.完成后,我们希望它通知此线程:

all_done = Queue.new
workers.last.when_done { all_done.enq :done }

我们走吧!

现在剩下的就是启动第一个线程:

workers.first.start

并等待最后一个线程完成:

all_done.deq

输出:

Thread 1
Thread 2
Thread 3
Thread 4
Thread 5
Thread 6

转载注明原文:Ruby同步:如何使线程以正确的顺序一个接一个地工作? - 代码日志