asynchronous 0.1.0 → 0.1.1

data/README.md

@@ -2,7 +2,58 @@ asynchronous
 ============
 
 Asynchronous Patterns for Ruby Based on Pure MRI CRuby code
+The goal is to use the original MRI C libs for achive
+real async patterns in ruby
 
+Well it is achived...
+
+
+# OS managed thread
+
+copy on write memory share,
+so you cant change anything in the mother process
+only with the return value later.
+This method is stronger the more CPU core the os have
+
+Ideal for Big jobs that require lot of memory allocation or
+heavy CPU load to get a value
+Like parsing (in some case)
+
+```ruby
+
+calculation = async :parallelism do
+
+  sleep 4
+  # remember, everything you
+  # write here only mather in this block
+  # will not affect the real process only
+  # the last return value of the block
+  4 * 5
+
+end
+
+# to call the value (syncronize):
+calculation.value
+
+```
+
+# VM managed thread
+
+you can use simple :c also instead of :concurrency as sym,
+remember :concurrency is all about GIL case, so
+you can modify the objects in memory
+This is ideal for little operations in simultaneously or
+when you need to update objects in the memory and not the
+return value what is mather.
+Remember well that GarbageCollector will affect the speed.
+
+```ruby
+
+calculation= async { sleep 3; 4 * 3 }
+# to call the value (syncronize):
+calculation.value
+
+```
 # Examples
 
 the "simple async processing" will let you use os threads (1.9.n+)

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/asynchronous/concurrency.rb

@@ -10,13 +10,20 @@ module Asynchronous
     def initialize(callable)
       begin
         @value= nil
+        @try_count= 0
         @rescue_state= nil
         @thread ||= ::Thread.new { callable.call }
         @rescue_state= nil
       rescue ThreadError
         @rescue_state ||= true
-        sleep 5
-        retry
+        @try_count += 1
+        if 3 <= @try_count
+          @value= callable.call
+          @rescue_state= nil
+        else
+          sleep 5
+          retry
+        end
       end
     end
 

data/lib/asynchronous/parallelism.rb

@@ -11,8 +11,6 @@ module Asynchronous
 
     # Basic
     begin
-
-      #require 'yaml'
       @@pids=[]
       def initialize callable
 
@@ -33,7 +31,6 @@ module Asynchronous
         @@pids.push(@pid)
 
       end
-
     end
 
     # return value
@@ -56,22 +53,13 @@ module Asynchronous
 
       end
 
-
       def value=(obj)
         @value= obj
       end
 
-      #def method_missing(method,*args)
-      #  value.__send__(method,*args)
-      #end
-      #
-      #def respond_to_missing?(method, include_private = false)
-      #  value.respond_to?(method, include_private)
-      #end
-
     end
 
-    # kill Zombies at Kernel Exit
+    # kill kidos at Kernel Exit
     begin
       ::Kernel.at_exit {
         @@pids.each { |pid|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asynchronous
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-10 00:00:00.000000000 Z
+date: 2014-01-11 00:00:00.000000000 Z
 dependencies: []
 description: ! 'Async dsl for easy concurrency patterns in both VM managed and OS
   managed way (Concurrency and Parallelism) '