rbgo 0.2.9 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4811ffce7c609abea9507fc023c9383121d232d6b79cb221e1ac62980ea879a0
-  data.tar.gz: 297e658752df154a7e5202cd2d6801c5b4aef3399229710f1b37bc0e6e025868
+  metadata.gz: c619996e5259a7e326d0a4740643b440895edf64534c7211df3acb912842b807
+  data.tar.gz: f6fc47754f814abd62bd0c148d867e14a4f7f594596ae6a2bbdb942defc219ca
 SHA512:
-  metadata.gz: 70ba89e8bb29f007a40e51d715306da0cec8ebb9c71331e2f60d08e46005ca12d44eb5e18dace1b531f758b226abe40e1c31f7101d78c95a3864db2410d30c40
-  data.tar.gz: 8ffd9db409f9714c7d160d994a19f38d0ffbacd0fb115a77ade48574ba326f73a40b8389a105703386fa524676cfa5b318acc663c37e72d71510f421317f9060
+  metadata.gz: aeba922a5d896fa22477dd00d35516613ac0ac90ebfc6ec18205390b8b6944b698a2fc0242d3b576cfee7f6d7605e11a4051dd7f5a6ce92872ae0201e576dcd7
+  data.tar.gz: 49d515cfa355b8e9c1ad74629b37a2887c4ca0fed48e637a6a7f25549724f00cd72e12b5786c88824b05f5b169aaf6338a6ad5bda0973ab98bbd3c0a67c29c95

data/README.md

@@ -1,11 +1,3 @@
-# I like the way how golang does in concurrency.
- 
-You can produce a light weight routine easily with a keyword 'go' and communicate with each routine by channel.
-
-In MRI the GIL prevents you from running code parallelly, but there ara also other ruby implementations such as TruffleRuby or JRuby which can utilize all CPU cores.
-
-In MRI write program to run concurrently even not parallelly is also important.
-
 # This project is trying to help writing concurrent program with ruby a little easier.     
 
 # select_chan                       
@@ -129,6 +121,82 @@ actor = Rbgo::Actor.new do|msg, actor|
 
 actor.send_msg :msg1 #won't block
 
+# TaskList do task in order but do it asynchronously, task may be executed in different thread
+ 
+task_list = Rbgo::TaskList.new
+
+task_1 = proc do
+  puts 'first'
+  1
+end
+
+task_2 = proc do |last_result|
+  puts 'second'
+  puts "last task result #{last_result}"
+  sleep 5
+  2
+end
+
+task_3 = proc do |last_result|
+  puts 'third'
+  puts "last task result #{last_result}"
+  3
+end
+
+task_list << task_1
+task_list.add(task_2, timeout: 2, skip_on_exception: true)
+task_list << task_3
+
+task_list.start
+task_list.wait
+p 'wait done.'                          
+p task_list.complete?
+p task_list.last_error
+                       
+# Reentrant/ReadWirte Mutex and Semaphore
+
+m = Rbgo::ReentrantMutex.new
+m.synchronize do
+  m.synchronize do
+    puts "I'm here!"
+  end
+end
+
+m2 = Rbgo::RWMutex.new
+5.times do
+  go do
+    m2.synchronize_r do
+      puts "got the read lock"
+    end
+  end
+end
+go do
+  m2.synchronize_w do
+    puts "got the write lock"
+    m2.synchronize_r do
+      puts 'now, downgrade to read lock'
+    end
+  end
+end
+
+sleep 2
+
+go do
+  s = Rbgo::Semaphore.new(5)
+
+  s.acquire(4) do
+    puts 'got the permits'
+  end
+
+  s.acquire_all do
+    puts 'got all available permits'
+  end
+
+  ok = s.try_acquire do
+    puts 'try success'
+  end
+  puts 'try ok!' if ok
+end
 ```            
 # IOMachine
 IOMachine wrap nio4r to do IO operation asynchronously.
@@ -207,9 +275,6 @@ io_w.close
 #   fiber.resume
 # end
 # 
-# go! do
-#   io_r.yield_read # will not do yield. just do normal IO#read
-# end
 
 ```
 

data/lib/rbgo/actor.rb

@@ -1,23 +1,25 @@
 require 'thread'
-
+require_relative 'once'
 
 module Rbgo
   class Actor
     private
-    attr_accessor :mail_box
+
+    attr_accessor :mail_box, :once_for_msg_loop
 
     public
 
     attr_accessor :handler
 
     def initialize(&handler)
-      self.handler  = handler
-      self.mail_box = Queue.new
-      start_msg_loop
+      self.handler           = handler
+      self.mail_box          = Queue.new
+      self.once_for_msg_loop = Once.new
     end
 
     def send_msg(msg)
       mail_box << msg
+      start_msg_loop
       nil
     end
 
@@ -34,14 +36,28 @@ module Rbgo
     private
 
     def start_msg_loop
-      CoRun::Routine.new(new_thread: true, queue_tag: :default) do
-        loop do
-          break if mail_box.closed?
-          msg = mail_box.deq
-          handler.call(msg, self) rescue nil
-          Fiber.yield
+      once_for_msg_loop.do do
+        CoRun::Routine.new(new_thread: false, queue_tag: :default) do
+          loop do
+            begin
+              msg = mail_box.deq(true)
+            rescue ThreadError
+              self.once_for_msg_loop = Once.new
+              start_msg_loop unless mail_box.empty?
+              break
+            else
+              call_handler(msg)
+            end
+            Fiber.yield
+          end
         end
       end
     end
+
+    def call_handler(msg)
+      handler.call(msg, self) if handler
+    rescue Exception => ex
+      STDERR.puts ex
+    end
   end
 end

data/lib/rbgo/corun.rb

@@ -8,12 +8,18 @@ require_relative 'once'
 module Rbgo
   module CoRun
     IS_CORUN_FIBER     = :is_corun_fiber_bbc0f70e
+    LOCAL_TASK_QUEUES = :local_task_queues_bbc0f70e
     YIELD_IO_OPERATION = :yield_bbc0f70e
 
     def self.is_in_corun_fiber?
       !!Thread.current[IS_CORUN_FIBER]
     end
 
+    def self.have_other_task_on_thread?
+      queues = Thread.current.thread_variable_get(LOCAL_TASK_QUEUES)
+      queues&.any?{|q| !q.empty?}
+    end
+
     def self.read_from(io, length: nil)
       if is_in_corun_fiber?
         return "" if length == 0
@@ -62,6 +68,33 @@ module Rbgo
       end
     end
 
+    def self.recv_from(sock, maxlen:, flags: 0)
+      if is_in_corun_fiber?
+        receipt = Scheduler.instance.io_machine.do_socket_recv(sock, maxlen: maxlen, flags: flags)
+        Fiber.yield [YIELD_IO_OPERATION, receipt]
+      else
+        sock.recv(maxlen, flags)
+      end
+    end
+
+    def self.recvmsg_from(sock, maxdatalen: nil, flags: 0, maxcontrollen: nil, opts: {})
+      if is_in_corun_fiber?
+        receipt = Scheduler.instance.io_machine.do_socket_recvmsg(sock, maxdatalen: maxdatalen, flags: flags, maxcontrollen: maxcontrollen, opts: opts)
+        Fiber.yield [YIELD_IO_OPERATION, receipt]
+      else
+        sock.recvmsg(maxdatalen, flags, maxcontrollen, opts)
+      end
+    end
+
+    def self.sendmsg_to(sock, mesg, flags: 0, dest_sockaddr: nil, controls: [])
+      if is_in_corun_fiber?
+        receipt = Scheduler.instance.io_machine.do_socket_sendmsg(sock, mesg, flags: flags, dest_sockaddr: dest_sockaddr, controls: controls)
+        Fiber.yield [YIELD_IO_OPERATION, receipt]
+      else
+        sock.sendmsg(mesg, flags, dest_sockaddr, *controls)
+      end
+    end
+
     def self.write_to(io, str:)
       if is_in_corun_fiber?
         receipt = Scheduler.instance.io_machine.do_write(io, str: str)
@@ -90,7 +123,7 @@ module Rbgo
       end
 
       def perform
-        self.fiber = Fiber.new do |args|
+        self.fiber = Fiber.new do |*args|
           Thread.current[IS_CORUN_FIBER] = true
           blk.call(*args)
         end if fiber.nil?
@@ -169,6 +202,7 @@ module Rbgo
               yield_task_queue      = Queue.new
               pending_io_task_queue = Queue.new
               local_task_queue      = Queue.new
+              Thread.current.thread_variable_set(LOCAL_TASK_QUEUES,[yield_task_queue, pending_io_task_queue, local_task_queue])
               task_queue            = get_queue(queue_tag)
               local_task_queue << init_task if init_task
               loop do
@@ -338,6 +372,10 @@ module Rbgo
       def go!(*args, &blk)
         CoRun::Routine.new(*args, new_thread: true, queue_tag: :none, &blk)
       end
+
+      def have_other_task_on_thread?
+        CoRun.have_other_task_on_thread?
+      end
     end
 
     refine IO do
@@ -366,6 +404,18 @@ module Rbgo
       def yield_connect(remote_sockaddr)
         CoRun.connect_to(self, remote_sockaddr: remote_sockaddr)
       end
+
+      def yield_recv(maxlen, flags = 0)
+        CoRun.recv_from(self, maxlen: maxlen, flags: flags)
+      end
+
+      def yield_recvmsg(maxdatalen = nil, flags = 0, maxcontrollen = nil, opts = {})
+        CoRun.recvmsg_from(self, maxdatalen: maxdatalen, flags: flags, maxcontrollen: maxcontrollen, opts: opts)
+      end
+
+      def yield_sendmsg(mesg, flags = 0, dest_sockaddr = nil, *controls)
+        CoRun.sendmsg_to(self, mesg, flags: flags, dest_sockaddr: dest_sockaddr, controls: controls)
+      end
     end
   end
 end

data/lib/rbgo/io_machine.rb

@@ -80,6 +80,27 @@ module Rbgo
       receipt
     end
 
+    def do_socket_recv(sock, maxlen:, flags: 0)
+      op      = [:register_socket_recv, sock, maxlen, flags]
+      receipt = IOReceipt.new(op)
+      actor.send_msg(receipt)
+      receipt
+    end
+
+    def do_socket_recvmsg(sock, maxdatalen: nil, flags: 0, maxcontrollen: nil, opts: {})
+      op      = [:register_socket_recvmsg, sock, maxdatalen, flags, maxcontrollen, opts]
+      receipt = IOReceipt.new(op)
+      actor.send_msg(receipt)
+      receipt
+    end
+
+    def do_socket_sendmsg(sock, mesg, flags: 0, dest_sockaddr: nil, controls: [])
+      op      = [:register_socket_sendmsg, sock, mesg, flags, dest_sockaddr, controls]
+      receipt = IOReceipt.new(op)
+      actor.send_msg(receipt)
+      receipt
+    end
+
     def close
       actor.close
       selector.close
@@ -119,6 +140,12 @@ module Rbgo
           handle_socket_accept_msg(receipt, actor)
         when :register_socket_connect
           handle_socket_connect_msg(receipt, actor)
+        when :register_socket_recv
+          handle_socket_recv_msg(receipt, actor)
+        when :register_socket_sendmsg
+          handle_socket_sendmsg_msg(receipt, actor)
+        when :register_socket_recvmsg
+          handle_socket_recvmsg_msg(receipt, actor)
         end
       end #end of actor
 
@@ -144,8 +171,171 @@ module Rbgo
       nil
     end
 
-    def handle_socket_connect_msg(receipt, actor)
+    def handle_socket_recv_msg(receipt, actor)
+      op     = receipt.registered_op
+      io     = op[1]
+      maxlen = op[2]
+      flags  = op[3]
+      res    = ""
+
+      monitor = register(receipt, interest: :r)
+      return if monitor.nil?
+
+      monitor.value    ||= []
+      monitor.value[0] = proc do
+        notify_blk = proc do
+          monitors.delete(monitor.io)
+          monitor.close
+          receipt.res = res
+          receipt.notify
+        end
+        catch :exit do
+          begin
+            buf = io.recv_nonblock(maxlen, flags, exception: false)
+          rescue Exception => ex
+            notify_blk.call
+            STDERR.puts ex
+            throw :exit
+          end
+          if buf == :wait_readable
+            throw :exit
+          elsif buf.nil?
+            notify_blk.call
+            throw :exit
+          end
+          res << buf
+          notify_blk.call
+        end
+      end
+      actor.send_msg :do_select
+    end
+
+    def handle_socket_recvmsg_msg(receipt, actor)
+      op              = receipt.registered_op
+      sock            = op[1]
+      len             = op[2]
+      flags           = op[3]
+      maxcontrollen   = op[4]
+      opts            = op[5]
+
+      data            = ""
+      sender_addrinfo = nil
+      rflags          = 0
+      controls        = []
+
+      monitor = register(receipt, interest: :r)
+      return if monitor.nil?
+      notify_blk       = proc do
+        monitors.delete(monitor.io)
+        monitor.close
+        if len && len > 0 && data.length == 0
+          receipt.res = nil
+        else
+          receipt.res = [data, sender_addrinfo, rflags, *controls]
+        end
+        receipt.notify
+      end
+      monitor.value    ||= []
+      monitor.value[0] = proc do
+        if len.nil?
+          loop do
+            begin
+              buf = sock.recvmsg_nonblock(nil, flags, maxcontrollen, opts.merge(exception: false))
+            rescue Exception => ex
+              notify_blk.call
+              STDERR.puts ex
+              break
+            end
+            if buf == :wait_readable
+              break
+            elsif buf.nil?
+              notify_blk.call
+              break
+            end
+            data << buf[0]
+            sender_addrinfo = buf[1]
+            rflags          = buf[2]
+            controls.append(*buf[3..-1])
+          end
+        elsif len == 0
+          notify_blk.call
+          break
+        else
+          bytes_read_n = 0
+          loop do
+            need_read_bytes_n = len - bytes_read_n
+            if need_read_bytes_n <= 0
+              notify_blk.call
+              break
+            end
+            begin
+              buf = sock.recvmsg_nonblock(need_read_bytes_n, flags, maxcontrollen, opts.merge(exception: false))
+            rescue Exception => ex
+              notify_blk.call
+              STDERR.puts ex
+              break
+            end
+            if buf == :wait_readable
+              break
+            elsif buf.nil?
+              notify_blk.call
+              break
+            end
+            data << buf[0]
+            sender_addrinfo = buf[1]
+            rflags          = buf[2]
+            controls.append(*buf[3..-1])
+            bytes_read_n += buf[0].bytesize
+          end
+        end
+      end
+      actor.send_msg :do_select
+    end
+
+    def handle_socket_sendmsg_msg(receipt, actor)
+      op            = receipt.registered_op
+      sock          = op[1]
+      str           = op[2].to_s
+      flags         = op[3]
+      dest_sockaddr = op[4]
+      controls      = op[5]
+      monitor       = register(receipt, interest: :w)
+      return if monitor.nil?
 
+      bytes_written_n  = 0
+      monitor.value    ||= []
+      monitor.value[1] = proc do
+        loop do
+          begin
+            bytes_need_to_write_n = str.size - bytes_written_n
+            if bytes_need_to_write_n > 0
+              n = sock.sendmsg_nonblock(str[bytes_written_n..-1], flags, dest_sockaddr, *controls, exception: false)
+            else
+              monitors.delete(monitor.io)
+              monitor.close
+              receipt.res = str.bytesize
+              receipt.notify
+              break
+            end
+          rescue Exception => ex
+            monitors.delete(monitor.io)
+            monitor.close
+            receipt.res = bytes_written_n
+            receipt.notify
+            STDERR.puts ex
+            break
+          end
+          if n == :wait_writable
+            break
+          end
+          bytes_written_n += n
+        end
+      end
+      monitor.value[1].call
+      actor.send_msg :do_select
+    end
+
+    def handle_socket_connect_msg(receipt, actor)
       op              = receipt.registered_op
       sock            = op[1]
       remote_sockaddr = op[2]
@@ -278,10 +468,17 @@ module Rbgo
         sep        = "\n\n" if (sep && sep.length == 0)
 
         if limit.nil?
-          buf_size = 1 unless sep.nil?
+          buf_size = 1 unless sep.nil? || io.is_a?(BasicSocket)
           loop do
             begin
-              buf = io.read_nonblock(buf_size, exception: false)
+              if sep && io.is_a?(BasicSocket)
+                buf = io.recv_nonblock(buf_size, Socket::MSG_PEEK, exception: false)
+                if buf != :wait_readable && buf.size == 0
+                  buf = nil
+                end
+              else
+                buf = io.read_nonblock(buf_size, exception: false)
+              end
             rescue Exception => ex
               notify_blk.call
               STDERR.puts ex
@@ -293,7 +490,16 @@ module Rbgo
               notify_blk.call
               break
             end
-            res << buf
+            if sep && io.is_a?(BasicSocket)
+              sep_index = buf.index(sep)
+              if sep_index
+                buf = buf[0...sep_index + sep.length]
+              end
+              res << buf
+              io.recv(buf.size)
+            else
+              res << buf
+            end
             unless sep.nil?
               if res.end_with?(sep)
                 notify_blk.call
@@ -309,13 +515,20 @@ module Rbgo
               notify_blk.call
               break
             end
-            if sep.nil?
+            if sep.nil? || io.is_a?(BasicSocket)
               buf_size = need_read_bytes_n
             else
               buf_size = 1
             end
             begin
-              buf = io.read_nonblock(buf_size, exception: false)
+              if sep && io.is_a?(BasicSocket)
+                buf = io.recv_nonblock(buf_size, Socket::MSG_PEEK, exception: false)
+                if buf != :wait_readable && buf.size == 0
+                  buf = nil
+                end
+              else
+                buf = io.read_nonblock(buf_size, exception: false)
+              end
             rescue Exception => ex
               notify_blk.call
               STDERR.puts ex
@@ -327,7 +540,16 @@ module Rbgo
               notify_blk.call
               break
             end
-            res << buf
+            if sep && io.is_a?(BasicSocket)
+              sep_index = buf.index(sep)
+              if sep_index
+                buf = buf[0...sep_index + sep.length]
+              end
+              res << buf
+              io.recv(buf.size)
+            else
+              res << buf
+            end
             bytes_read_n += buf.bytesize
             unless sep.nil?
               if res.end_with?(sep)
@@ -343,7 +565,6 @@ module Rbgo
       actor.send_msg :do_select
     end
 
-
     def handle_read_msg(receipt, actor)
       op       = receipt.registered_op
       io       = op[1]
@@ -414,7 +635,6 @@ module Rbgo
       actor.send_msg :do_select
     end
 
-
     def handle_write_msg(receipt, actor)
       op  = receipt.registered_op
       io  = op[1]
@@ -451,7 +671,6 @@ module Rbgo
       actor.send_msg :do_select
     end
 
-
     def register(receipt, interest:)
       io                 = receipt.registered_op[1]
       registered_monitor = monitors[io]
@@ -469,6 +688,5 @@ module Rbgo
       end
       monitor
     end
-
   end
 end

data/lib/rbgo/reentrant_mutex.rb

@@ -0,0 +1,84 @@
+# Copyright (c) 2014 Boris Bera
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+#                                  distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Rbgo
+  class ReentrantMutex < Mutex
+    def initialize
+      @count_mutex = Mutex.new
+      @counts      = Hash.new(0)
+
+      super
+    end
+
+    def synchronize
+      raise ThreadError, 'Must be called with a block' unless block_given?
+
+      begin
+        lock
+        yield
+      ensure
+        unlock
+      end
+    end
+
+    def lock
+      c = increase_count Thread.current
+      super if c <= 1
+      self
+    end
+
+    def unlock
+      c = decrease_count Thread.current
+      if c <= 0
+        super
+        delete_count Thread.current
+      end
+      self
+    end
+
+    def try_lock
+      if owned?
+        lock
+        return true
+      else
+        ok = super
+        increase_count Thread.current if ok
+        return ok
+      end
+    end
+
+    private
+
+    def increase_count(thread)
+      @count_mutex.synchronize { @counts[thread] += 1 }
+    end
+
+    def decrease_count(thread)
+      @count_mutex.synchronize { @counts[thread] -= 1 }
+    end
+
+    def delete_count(thread)
+      @count_mutex.synchronize { @counts.delete(thread) }
+    end
+  end
+end

data/lib/rbgo/reentrant_rw_mutex.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'reentrant_mutex'
+module Rbgo
+  class RWMutex
+
+    def initialize
+      @lock_count = Hash.new(0)
+      @mutex      = ReentrantMutex.new
+      @cond       = ConditionVariable.new
+      @status     = :unlocked
+    end
+
+    def owned?
+      @mutex.synchronize do
+        @lock_count.key? Thread.current
+      end
+    end
+
+    def locked?
+      @mutex.synchronize do
+        if @lock_count.empty?
+          return false
+        else
+          return true
+        end
+      end
+    end
+
+    def synchronize_r
+      raise ThreadError, 'Must be called with a block' unless block_given?
+
+      begin
+        lock_r
+        yield
+      ensure
+        unlock
+      end
+    end
+
+    def synchronize_w
+      raise ThreadError, 'Must be called with a block' unless block_given?
+
+      begin
+        lock_w
+        yield
+      ensure
+        unlock
+      end
+    end
+
+    private
+
+    def lock_r
+      @mutex.synchronize do
+        case @status
+        when :locked_for_write
+          until @status == :unlocked || @status == :locked_for_read || owned?
+            @cond.wait(@mutex)
+          end
+        end
+        tmp_status                  = @status
+        @status                     = :locked_for_read
+        @lock_count[Thread.current] += 1
+        if owned? && tmp_status == :locked_for_write
+          @cond.broadcast
+        end
+        return self
+      end
+    end
+
+    def lock_w
+      @mutex.synchronize do
+        until @status == :unlocked || (owned? && @status == :locked_for_write)
+          @cond.wait(@mutex)
+        end
+        @status                     = :locked_for_write
+        @lock_count[Thread.current] += 1
+        return self
+      end
+    end
+
+    def unlock
+      @mutex.synchronize do
+        if owned?
+          @lock_count[Thread.current] -= 1
+          @lock_count.delete(Thread.current) if @lock_count[Thread.current] == 0
+          if @lock_count.empty?
+            @status = :unlocked
+            @cond.broadcast
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbgo/semaphore.rb

@@ -0,0 +1,99 @@
+module Rbgo
+  class Semaphore
+    def initialize(count)
+      count = count.to_i
+      raise 'count must be positive' if count <= 0
+      @mutex = Mutex.new
+      @cond  = ConditionVariable.new
+      @count = count
+    end
+
+    def available_permits
+      @mutex.synchronize do
+        return @count
+      end
+    end
+
+    def acquire(permits = 1)
+      raise 'Must be called with a block' unless block_given?
+
+      begin
+       ok = _acquire(permits)
+        yield
+      ensure
+        release(permits) if ok
+      end
+    end
+
+    def acquire_all
+      raise 'Must be called with a block' unless block_given?
+
+      begin
+        permits = drain_permits
+        yield
+      ensure
+        release(permits)
+      end
+    end
+
+    def try_acquire(permits = 1)
+      raise 'Must be called with a block' unless block_given?
+
+      begin
+        ok = _try_acquire(permits)
+        yield if ok
+      ensure
+        release(permits) if ok
+      end
+      return ok
+    end
+
+    def release(permits = 1)
+      permits = permits.to_i
+      raise 'permits must be positive' if permits <= 0
+      @mutex.synchronize do
+        @count += permits
+        @cond.broadcast
+      end
+      self
+    end
+
+    private
+
+    def _acquire(permits = 1)
+      permits = permits.to_i
+      raise 'permits must be positive' if permits <= 0
+      @mutex.synchronize do
+        while @count - permits < 0
+          @cond.wait(@mutex)
+        end
+        @count -= permits
+        return self
+      end
+    end
+
+    def drain_permits
+      @mutex.synchronize do
+        while @count <= 0
+          @cond.wait(@mutex)
+        end
+        tmp_count = @count
+        @count = 0
+        return tmp_count
+      end
+    end
+
+    def _try_acquire(permits = 1)
+      permits = permits.to_i
+      raise 'permits must be positive' if permits <= 0
+      @mutex.synchronize do
+        if @count - permits < 0
+          return false
+        else
+          @count -= permits
+          return true
+        end
+      end
+    end
+  end
+end

data/lib/rbgo/synchronized_collection.rb

@@ -0,0 +1,75 @@
+require 'monitor'
+require 'set'
+
+module Rbgo
+  class SyncArray
+    def self.[](*args)
+      SyncArray.new(Array.[](*args))
+    end
+
+    def self.try_convert(obj)
+      a = Array.try_convert(obj)
+      a.nil? ? nil : SyncArray.new(a)
+    end
+
+    def initialize(*args, &blk)
+      @a = Array.new(*args, &blk)
+      @a.extend(MonitorMixin)
+    end
+
+    Array.public_instance_methods.each do |m|
+      define_method(m) do |*args, &blk|
+        @a.synchronize do
+          @a.send m, *args, &blk
+        end
+      end
+    end
+  end
+
+  class SyncHash
+    def self.[](*args)
+      h = SyncHash.new
+      h.instance_eval do
+        @h = Hash.[](*args)
+        @h.extend(MonitorMixin)
+      end
+    end
+
+    def self.try_convert(obj)
+      h = Hash.try_convert(obj)
+      h.nil? ? nil : SyncHash.[](h)
+    end
+
+    def initialize(*args, &blk)
+      @h = Hash.new(*args, &blk)
+      @h.extend(MonitorMixin)
+    end
+
+    Hash.public_instance_methods.each do |m|
+      define_method(m) do |*args, &blk|
+        @h.synchronize do
+          @h.send m, *args, &blk
+        end
+      end
+    end
+  end
+
+  class SyncSet
+    def self.[](*args)
+      SyncSet.new(Set.[](*args))
+    end
+
+    def initialize(enum = nil)
+      @s = Set.new(enum)
+      @s.extend(MonitorMixin)
+    end
+
+    Set.public_instance_methods.each do |m|
+      define_method(m) do |*args, &blk|
+        @s.synchronize do
+          @s.send m, *args, &blk
+        end
+      end
+    end
+  end
+end

data/lib/rbgo/task_list.rb

@@ -0,0 +1,102 @@
+require 'thread'
+require 'timeout'
+
+module Rbgo
+  using CoRunExtensions
+
+  class TaskList
+    attr_accessor :last_error
+
+    def <<(task)
+      task_queue << task
+      self
+    end
+
+    def add(task, timeout: nil, skip_on_exception: false)
+      task_queue << proc do |last_task_result|
+        begin
+          Timeout::timeout(timeout) do
+            task.call(last_task_result)
+          end
+        rescue Exception => ex
+          self.last_error = ex
+          raise unless skip_on_exception
+        end
+      end
+      self
+    end
+
+    def start(arg = nil)
+      start_once.do do
+        _start(arg)
+      end
+      nil
+    end
+
+    def clear_task
+      task_queue.clear
+    end
+
+    def running?
+      running
+    end
+
+    def complete?
+      !running? && task_queue.empty?
+    end
+
+    def wakeup
+      wait_cond.signal
+    end
+
+    def wait(timeout = nil)
+      wait_mutex.synchronize do
+        if running?
+          wait_cond.wait(wait_mutex, timeout)
+        end
+      end
+    end
+
+    private
+
+    attr_accessor :task_queue, :start_once, :running, :wait_mutex, :wait_cond
+
+    def initialize
+      self.task_queue = Queue.new
+      self.start_once = Once.new
+      self.running    = false
+      self.wait_mutex = Mutex.new
+      self.wait_cond  = ConditionVariable.new
+    end
+
+    def notify
+      wait_mutex.synchronize do
+        self.running = false
+        wait_cond.signal
+      end
+    end
+
+    def _start(arg = nil)
+      self.last_error = nil unless running?
+      self.running    = true
+      go(arg) do |last_task_result|
+        begin
+          task = task_queue.deq(true)
+        rescue ThreadError
+          notify
+          self.start_once = Once.new
+        else
+          begin
+            res = task.call(last_task_result)
+          rescue Exception => ex
+            self.last_error = ex
+            notify
+            self.start_once = Once.new
+          else
+            _start(res)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbgo/version.rb

@@ -1,3 +1,3 @@
 module Rbgo
-  VERSION = "0.2.9"
+  VERSION = "0.2.15"
 end

data/lib/rbgo/wait_group.rb

@@ -3,12 +3,13 @@ require 'thread'
 module Rbgo
   class WaitGroup
     def initialize(init_count = 0)
-      self.total_count = [0, init_count].max
+      self.total_count = [0, init_count.to_i].max
       self.mutex       = Mutex.new
       self.cond        = ConditionVariable.new
     end
 
     def add(count)
+      count = count.to_i
       mutex.synchronize do
         c = total_count + count
         if c < 0

data/lib/rbgo.rb

@@ -1,8 +1,13 @@
 require_relative 'rbgo/corun'
 require_relative 'rbgo/select_chan'
 require_relative 'rbgo/wait_group'
+require_relative 'rbgo/reentrant_mutex'
+require_relative 'rbgo/reentrant_rw_mutex'
+require_relative 'rbgo/semaphore'
+require_relative 'rbgo/synchronized_collection'
 require_relative 'rbgo/once'
 require_relative 'rbgo/actor'
+require_relative 'rbgo/task_list'
 require_relative 'rbgo/io_machine'
 require_relative 'rbgo/network_service'
 require_relative 'rbgo/version'

data/rbgo.gemspec

@@ -10,15 +10,7 @@ Gem::Specification.new do |s|
   s.email       = ["24588062@qq.com"]
   s.homepage    = "https://github.com/wangyin-git/rbgo"
   s.summary     = "Write concurrent program with Ruby in Golang style"
-  s.description = <<-END
-                    Write concurrent program with Ruby in Golang style.  
-
-                    You can produce a light weight routine easily with a method 'go' and communicate with each routine by channel.
-
-                    In MRI the GIL prevents you from running code parallelly, but there ara also other ruby implementations such as TruffleRuby or JRuby which can utilize all CPU cores.
-
-                    In MRI write program to run concurrently even not parallelly is also important.
-                  END
+  s.description = "Write concurrent program with Ruby in Golang style."
   s.add_dependency "system", "~> 0.1.3"
   s.add_dependency "nio4r", "~> 2.4"
   s.files         = `git ls-files`.split("\n")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbgo
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.15
 platform: ruby
 authors:
 - Wang Yin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-14 00:00:00.000000000 Z
+date: 2019-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: system
@@ -38,13 +38,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
-description: "                    Write concurrent program with Ruby in Golang style.
-  \ \n\n                    You can produce a light weight routine easily with a method
-  'go' and communicate with each routine by channel.\n\n                    In MRI
-  the GIL prevents you from running code parallelly, but there ara also other ruby
-  implementations such as TruffleRuby or JRuby which can utilize all CPU cores.\n\n
-  \                   In MRI write program to run concurrently even not parallelly
-  is also important.\n"
+description: Write concurrent program with Ruby in Golang style.
 email:
 - 24588062@qq.com
 executables: []
@@ -61,7 +55,12 @@ files:
 - lib/rbgo/io_machine.rb
 - lib/rbgo/network_service.rb
 - lib/rbgo/once.rb
+- lib/rbgo/reentrant_mutex.rb
+- lib/rbgo/reentrant_rw_mutex.rb
 - lib/rbgo/select_chan.rb
+- lib/rbgo/semaphore.rb
+- lib/rbgo/synchronized_collection.rb
+- lib/rbgo/task_list.rb
 - lib/rbgo/version.rb
 - lib/rbgo/wait_group.rb
 - rbgo.gemspec