go_chanel 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 67dbc282f9ad1d4a8d5e0c41bd263f206e576c05
+  data.tar.gz: 94642ea6a66a3aba7296356cba9f0c327b4b4880
+SHA512:
+  metadata.gz: b948c6a7297ebc6a87323835759267819420b7f97781cc93463d256413a4d6dcc4f53b277f1fb6f33978d97e503066a221597c89d784ac01b9468e7f829315ad
+  data.tar.gz: bd647e0dcdce5a93d7609e66052566e46b301bc2890ee97b6f5e817cfa7e22939cd26e7307f92928b478b47210a1680b6537297082e73e9513a51fae3541f820

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://ruby.taobao.org'
+
+gemspec
+
+group :development, :test do
+  gem 'pry', '~> 0.10.1'
+  gem 'mocha', :require => false
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 xuxiangyang
+
+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.

data/README.md

@@ -0,0 +1,131 @@
+# GoChanel
+模仿golang中的channel。chanel是因为我拼写错了。。。。
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'go_chanel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install go_chanel
+
+## Usage
+
+最重要的组成是channel。也就是`GOChanel::Chanel`。它是所有的核心。
+一个channel是这样的：
+* 它是一个FIFO的队列，它支持push、pop、close。默认容量是1
+* 向一个Buffer满了的channel中push会阻塞
+* 向一个closed的channel中push会抛出异常
+* 从一个Buffer空了的channel中pop会阻塞
+* 从一个closed的channle中pop不会抛异常，会返回一个变量说channel关闭了
+总之他就是在模拟golang中的channel
+
+###GoChanel::Chanel的用法例子
+```ruby
+chanel = GoChanel::Chanel.new # 新建了一个容量为1的chanel
+chanel.push(1) #向chanel中push一次，这时还不会阻塞
+obj, ok = chanel.pop #obj是队列里的东西，ok是说这个chanel有没有关闭，如果close的话ok就会是false
+chanel.close #这个一般是在完成push之后关闭
+```
+
+更复杂点的用法，一般是主线程只负责分线程。我喜欢这样的用法：
+```ruby
+def main
+  concurrency_chan = GoChanel::Chanel.new
+  Thread.new {
+    puts "hello world"
+    concurrency_chan.push(true)
+  }
+  concurrency_chan.pop
+end
+```
+
+更复杂的用法, 也就是更高的并发
+
+```ruby
+def main
+  finish_func1 = GoChanel::Chanel.new
+  finish_func2 = GoChanel::Chanel.new
+  buffer_chan = GoChanel::Chanel.new(128)
+  Thread.new {
+    func1(buffer_chan)
+    finish_func1.push(true)
+  }
+  Thread.new {
+    func2(buffer_chan)
+    finish_func2.push(true)
+  }
+  finish_func1.pop
+  finish_func2.pop
+end
+def func1(out_chan)
+  1024.times do |i|
+    out_chan.push(i)
+  end
+  out_chan.close
+end
+def func2(in_chan)
+  concurrency_chan = GoChanel::Chanel.new(512) #512个并发
+  while true do
+    obj, ok = in_chan.pop
+    break unless ok
+    concurrency_chan.push(true)
+    Thread.new(obj) do |str|
+      puts str
+      concurrency_chan.pop
+    end
+  end
+end
+```
+
+###并发的Pipe
+类似于linux中的pipe，一个pipe的定义是这样的
+* 由至少2个pool组成
+* 分为三类pool，头、中间、尾。头只有一个out_chan, 中间的有一个in_chan也有一个out_chan, 尾只有一个in_chan
+* 对于中间和尾部的pool, 前一个pool的block返回值应该可以作为下一个pool block的输入
+* 头pool比较特殊，其实他是单线程执行的，因为一般头pool是重cpu的操作，分成多个thread也没有意义，它的返回值是一个array，依次传递给下一个pool
+用法如下,还是完成上一个复杂的例子，就会很简单
+
+```ruby
+pool1 = GoChanel::Pool.new(1) do
+  1024.times.to_a
+end
+pool2 = GoChanle::Pool.new(512) do |i|
+  puts i
+end
+pipe = pool1 | pool2
+pipe.run
+```
+
+另一个例子
+
+```ruby
+pool1 = GoChanel::Pool.new do
+  1024.times.map do |i|
+    [i + 1, i + 2]
+  end
+end
+pool2 = GoChanel::Pool.new(128) do |i, j|
+  i + j #一般为IO操作，这里就最简单的表示了
+end
+pool3 = GoChanel::Pool.new(32) do |i|
+  puts i
+end
+pipe = pool1 | pool2 | pool3
+pipe.run
+```
+
+###很重要：记住Thread和Progress的区别
+## Contributing
+
+1. Fork it ( https://github.com/xuxiangyang/go_chanel/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/go_chanel.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'go_chanel'
+Gem::Specification.new do |spec|
+  spec.name          = "go_chanel"
+  spec.version       = GoChanel::VERSION
+  spec.authors       = ["xuxiangyang"]
+  spec.email         = ["54049924@qq.com"]
+  spec.summary       = %q{simulate golang channel}
+  spec.description   = %q{simulate golang channel}
+  spec.homepage      = "https://github.com/xuxiangyang/go_chanel"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib/"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.4"
+end

data/lib/go_chanel.rb

@@ -0,0 +1,14 @@
+require "go_chanel/version"
+require "go_chanel/chanel"
+require "go_chanel/pool"
+require "go_chanel/pipe"
+require "go_chanel/task"
+require "go_chanel/err_notifier"
+
+module GoChanel
+  def self.go(*args, &proc)
+    Thread.new(args) do |params|
+      proc.call(*params)
+    end
+  end
+end

data/lib/go_chanel/chanel.rb

@@ -0,0 +1,63 @@
+# chanel is a FIFO queue.
+# It will sleep when push into a channel with full buffer.
+# It will sleep when pop from an empty channel
+# It will raise Exception when push into a closed channel
+# It will still work when pop form an empty channel
+# just like go channel
+
+module GoChanel
+  class Chanel
+    def initialize(cap_size = 1, objs = [])
+      raise ChanelException.new("can not create a 0 size channel") if cap_size < 1
+
+      @obj_mutex = Mutex.new
+      @close_mutex = Mutex.new
+      @cap_size = cap_size
+      @objs = objs
+      @closed = false
+    end
+
+    def push(obj)
+      raise ChanelException.new("can not push to closed channel") if @closed
+
+      while @objs.count >= @cap_size do
+        raise ChanelException.new("can not push to closed channel") if @closed
+        sleep(0.1)
+      end
+
+      @obj_mutex.synchronize do
+        @objs.push(obj)
+      end
+    end
+
+    def pop
+      while @objs.count == 0 do
+        return nil, false if @closed
+        sleep(0.1)
+      end
+
+      obj = @obj_mutex.synchronize do
+        @objs.shift
+      end
+
+      return obj, true
+    end
+
+    def size
+      @objs.count
+    end
+
+    def cap
+      @cap_size
+    end
+
+    def close
+      @close_mutex.synchronize do
+        @closed = true
+      end
+    end
+  end
+
+  class ChanelException < StandardError
+  end
+end

data/lib/go_chanel/err_notifier.rb

@@ -0,0 +1,30 @@
+module GoChanel
+  class ErrNotifier
+    @@notifier = nil
+    @@std_out = true
+    @@mutex = Mutex.new
+    def self.register(notifier, std_out = false)
+      @@notifier = notifier
+      @@std_out = std_out
+      raise "notifier should have a func named as" unless notifier.respond_to?(:notify)
+    end
+
+    def self.std_out=(open = true)
+      @@std_out = open
+    end
+
+    def self.notify(e)
+      if @@std_out
+        puts "Something wrong in Thread:"
+        puts e
+        puts e.backtrace
+      end
+
+      if @@notifier.present?
+        @@mutex.synchronize do
+          notifier.notify(e)
+        end
+      end
+    end
+  end
+end

data/lib/go_chanel/pipe.rb

@@ -0,0 +1,82 @@
+module GoChanel
+  class Pipe
+    attr_accessor :pools
+    def self.|(pool)
+      pipe = Pipe.new
+      pipe.pools << pool
+      pipe
+    end
+
+    def initialize
+      @pools = []
+    end
+
+    def |(pool)
+      @pools << pool
+      self
+    end
+
+    def run(*args)
+      raise PipeException.new("at_leaset pipe two pools") if @pools.count < 2
+      concurrence_chan = GoChanel::Chanel.new(@pools.count)
+
+      chans = build_chans
+
+      start_pool = @pools.shift
+      last_pool = @pools.pop
+
+      Thread.new(args) do |params|
+        begin
+          GoChanel::Task.start_task(chans[0], *params, &start_pool.proc)
+        rescue => e
+          GoChanel::ErrNotifier.notify(e)
+        ensure
+          concurrence_chan.push(true)
+        end
+      end
+
+      #no head and tail
+      @pools.each_with_index do |pool, i|
+        Thread.new do
+          begin
+            GoChanel::Task.normal_task(chans[i], chans[i + 1], pool.size, &pool.proc)
+          rescue => e
+            GoChanel::ErrNotifier.notify(e)
+          ensure
+            concurrence_chan.push(true)
+          end
+        end
+      end
+
+      Thread.new do
+        begin
+          GoChanel::Task.end_task(chans[-1], last_pool.size, &last_pool.proc)
+        rescue => e
+          GoChanel::ErrNotifier.notify(e)
+        ensure
+          concurrence_chan.push(true)
+        end
+      end
+
+      concurrence_chan.cap.times do
+        concurrence_chan.pop
+      end
+    end
+
+    private
+
+    def build_chans
+      chans = []
+
+      @pools.each_with_index do |pool, i|
+        next if i == 0
+        chans << GoChanel::Chanel.new(pool.size)
+      end
+
+      chans
+    end
+  end
+
+  class PipeException < StandardError
+  end
+end

data/lib/go_chanel/pool.rb

@@ -0,0 +1,17 @@
+require "go_chanel/chanel"
+module GoChanel
+  class Pool
+    attr_reader :size, :proc
+    def initialize(size = 1, &proc)
+      @size = size
+      @proc = proc
+    end
+
+    def |(pool)
+      pipe = Pipe.new
+      pipe.pools << self
+      pipe.pools << pool
+      pipe
+    end
+  end
+end

data/lib/go_chanel/task.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+module GoChanel
+  class Task
+    def self.normal_task(in_chan, out_chan, concurrence_count = 1, &proc)
+      concurrence_chan = GoChanel::Chanel.new(concurrence_count)
+      while true do
+        args, ok = in_chan.pop
+        break unless ok
+        concurrence_chan.push(true)
+        Thread.new(args) do |params|
+          begin
+            result = proc.call(*params)
+            out_chan.push(result)
+          rescue => e
+            GoChanel::ErrNotifier.notify(e)
+          ensure
+            concurrence_chan.pop
+          end
+        end
+      end
+
+      while concurrence_chan.size > 0 do
+        sleep(0.1)
+      end
+      out_chan.close
+    end
+
+    def self.start_task(out_chan, *args, &proc)
+      concurrence_chan = GoChanel::Chanel.new
+      Thread.new do
+        begin
+          proc.call(*args).each do |result|
+            out_chan.push(result)
+          end
+        rescue => e
+          GoChanel::ErrNotifier.notify(e)
+        ensure
+          concurrence_chan.push(true)
+        end
+      end
+      concurrence_chan.pop
+      out_chan.close
+    end
+
+    def self.end_task(in_chan, concurrence_count, &proc)
+      concurrence_chan = GoChanel::Chanel.new(concurrence_count)
+      while true do
+        args, ok = in_chan.pop
+        break unless ok
+        concurrence_chan.push(true)
+        Thread.new(args) do |params|
+          begin
+            proc.call(*params)
+          rescue => e
+            GoChanel::ErrNotifier.notify(e)
+          ensure
+            concurrence_chan.pop
+          end
+        end
+      end
+
+      while concurrence_chan.size > 0 do
+        sleep(0.1)
+      end
+    end
+  end
+end

data/lib/go_chanel/version.rb

@@ -0,0 +1,3 @@
+module GoChanel
+  VERSION = "0.0.1"
+end

data/test/test_chanel.rb

@@ -0,0 +1,71 @@
+require 'test/unit'
+require 'mocha/test_unit'
+
+class TestChanel < Test::Unit::TestCase
+  def test_0_cap_new_will_raise
+    assert_raise GoChanel::ChanelException do
+      GoChanel::Chanel.new(0)
+    end
+  end
+
+  def test_push_to_closed_channel_will_raise
+    chanel = GoChanel::Chanel.new
+    chanel.close
+
+    assert_raise GoChanel::ChanelException do
+      chanel.push(2)
+    end
+  end
+
+  def test_pop_from_closed_channel_will_not_raise
+    chanel = GoChanel::Chanel.new
+    chanel.push(1)
+    chanel.close
+
+    assert_nothing_raised do
+      chanel.pop
+    end
+  end
+
+  def test_pop_from_closed_will_return_not_ok
+    chanel = GoChanel::Chanel.new
+    chanel.push(1)
+    chanel.close
+
+    assert_equal [1, true], chanel.pop
+    assert_equal [nil, false], chanel.pop
+  end
+
+  def test_channel_is_fifo
+    chanel = GoChanel::Chanel.new(3)
+    chanel.push(1)
+    chanel.push(2)
+    chanel.push(3)
+
+    assert_equal 1, chanel.pop.first
+    assert_equal 2, chanel.pop.first
+    assert_equal 3, chanel.pop.first
+  end
+
+  def test_empty_chanel_pop_will_sleep
+    chanel = GoChanel::Chanel.new
+    chanel.push(1)
+    chanel.pop
+
+    chanel.stubs(:sleep).raises(Exception)
+
+    assert_raise Exception do
+      chanel.pop
+    end
+  end
+
+  def test_full_chanel_push_will_sleep
+    chanel = GoChanel::Chanel.new
+    chanel.push(1)
+    chanel.stubs(:sleep).raises(Exception)
+
+    assert_raise Exception do
+      chanel.push(1)
+    end
+  end
+end

data/test/test_go.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+
+class TestGo < Test::Unit::TestCase
+  def test_go
+    finish_push_chanel = GoChanel::Chanel.new
+    finish_pop_chanel = GoChanel::Chanel.new
+    chanel = GoChanel::Chanel.new
+    GoChanel.go(1) do |a|
+      chanel.push(1)
+      finish_push_chanel.push(true)
+    end
+
+
+    GoChanel.go do
+      finish_pop_chanel.push(true)
+    end
+    finish_push_chanel.pop
+    finish_pop_chanel.pop
+  end
+end

data/test/test_pipe.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'pry'
+
+class TestPipe < Test::Unit::TestCase
+  def test_pipe
+    count = 0
+    pool1 = GoChanel::Pool.new do |i|
+      [1]
+    end
+
+    pool2 = GoChanel::Pool.new do |i|
+      [i + 1, i + 2]
+    end
+
+    pool3 = GoChanel::Pool.new do |i, j|
+      count = i + j
+    end
+
+    pipe = pool1 | pool2 | pool3
+    pipe.run
+
+    assert_equal 5, count
+  end
+
+  def test_pipe_at_least_2_pool
+    pool1 = GoChanel::Pool.new(1) do |i|
+      i
+    end
+
+    pipe = GoChanel::Pipe | pool1
+    assert_raise GoChanel::PipeException do
+      pipe.run
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: go_chanel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- xuxiangyang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+description: simulate golang channel
+email:
+- 54049924@qq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- go_chanel.gemspec
+- lib/go_chanel.rb
+- lib/go_chanel/chanel.rb
+- lib/go_chanel/err_notifier.rb
+- lib/go_chanel/pipe.rb
+- lib/go_chanel/pool.rb
+- lib/go_chanel/task.rb
+- lib/go_chanel/version.rb
+- test/test_chanel.rb
+- test/test_go.rb
+- test/test_pipe.rb
+homepage: https://github.com/xuxiangyang/go_chanel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib/
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: simulate golang channel
+test_files:
+- test/test_chanel.rb
+- test/test_go.rb
+- test/test_pipe.rb