concurrent-ruby 1.0.3.pre3-java → 1.0.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d570e81d15c9f558cd3ba2af24a62a70eb6faf93
-  data.tar.gz: bdfd64699ab036b7f84ac1132c413bcab6394bdf
+  metadata.gz: a60be6dec008167a29f42577f31c869f60d2546b
+  data.tar.gz: 37bf185108dd03a4e4f2101f97fc326e2bafa892
 SHA512:
-  metadata.gz: 7b424a412239a0b44c1896282a744c2ff37e2e644630ee7a94a8ff04b596f3aac35ee5e853742a6e3f27150a11d784a945dc18ffce528355b756a801a0976766
-  data.tar.gz: 1817739fb6012cd8713b93d0010dbc590327d38c7b34a051e5a0076b9a2d38e5a805c00addbe287fb1f1a57b851a333e76710c256ebf1db0380c3119d66dfaa6
+  metadata.gz: 3ed4f2c8f8cf8ac4c05a87b6a489f5f89ad0e4d28dbe2ab9e272135557eb006f1b235cc1597b6c6540edf383a63e11f60bd25d0cfa047bc4a4fe9aa3d9ab56d4
+  data.tar.gz: 84c54fb9a82577f71a444c55ebac7893f4192273c567b742bffb44256e8b53a4669e9437c63373180f0e1d09b174be6a6b84435e710ffa057adcd486c3a77c5c

data/CHANGELOG.md

@@ -1,11 +1,39 @@
-## Current Release v1.0.2 (2 May 2016)
+## Current Release v1.0.4 (27 Dec 2016)
+
+concurrent-ruby:
+
+* Nothing
+
+concurrent-ruby-edge:
+
+* New promises' API renamed, lots of improvements, edge bumped to 0.3.0
+  * **Incompatible** with previous 0.2.3 version
+  * see https://github.com/ruby-concurrency/concurrent-ruby/pull/522
+
+## Release v1.0.3 (17 Dec 2016)
+
+* Trigger execution of flattened delayed futures
+* Avoid forking for processor_count if possible
+* Semaphore Mutex and JRuby parity
+* Adds Map#each as alias to Map#each_pair
+* Fix uninitialized instance variables
+* Make Fixnum, Bignum merger ready
+* Allows Promise#then to receive an executor
+* TimerSet now survives a fork
+* Reject promise on any exception
+* Allow ThreadLocalVar to be initialized with a block
+* Support Alpha with `Concurrent::processor_count`
+* Fixes format-security error when compiling ruby_193_compatible.h
+* Concurrent::Atom#swap fixed: reraise the exceptions from block
+
+## Release v1.0.2 (2 May 2016)
 
 * Fix bug with `Concurrent::Map` MRI backend `#inspect` method
 * Fix bug with `Concurrent::Map` MRI backend using `Hash#value?`
 * Improved documentation and examples
 * Minor updates to Edge
 
-### Release v1.0.1 (27 February 2016)
+## Release v1.0.1 (27 February 2016)
 
 * Fix "uninitialized constant Concurrent::ReentrantReadWriteLock" error.
 * Better handling of `autoload` vs. `require`.
@@ -18,7 +46,7 @@
 * Improved documentation.
 * Updated README and CONTRIBUTING.
 
-### Release v1.0.0 (13 November 2015)
+## Release v1.0.0 (13 November 2015)
 
 * Rename `attr_volatile_with_cas` to `attr_atomic`
 * Add `clear_each` to `LockFreeStack`
@@ -66,7 +94,7 @@
 * Many improved tests
 * Some internal reorganization
 
-### Release v0.9.1 (09 August 2015)
+## Release v0.9.1 (09 August 2015)
 
 * Fixed a Rubiniux bug in synchronization object
 * Fixed all interpreter warnings (except circular references)
@@ -80,7 +108,7 @@
 * `ThreadLocalVar#bind` method is now public
 * Refactored many tests
 
-### Release v0.9.0 (10 July 2015)
+## Release v0.9.0 (10 July 2015)
 
 * Updated `AtomicReference`
   - `AtomicReference#try_update` now simply returns instead of raising exception
@@ -179,14 +207,14 @@
 * Removed brute-force killing of threads in tests
 * Fixed a thread pool bug when the operating system cannot allocate more threads
 
-### Release v0.8.0 (25 January 2015)
+## Release v0.8.0 (25 January 2015)
 
 * C extension for MRI have been extracted into the `concurrent-ruby-ext` companion gem.
   Please see the README for more detail.
 * Better variable isolation in `Promise` and `Future` via an `:args` option
 * Continued to update intermittently failing tests
 
-### Release v0.7.2 (24 January 2015)
+## Release v0.7.2 (24 January 2015)
 
 * New `Semaphore` class based on [java.util.concurrent.Semaphore](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html)
 * New `Promise.all?` and `Promise.any?` class methods
@@ -203,7 +231,7 @@
 * Tests now run on new Travis build environment
 * Multiple documentation updates
 
-### Release v0.7.1 (4 December 2014)
+## Release v0.7.1 (4 December 2014)
 
 Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/issues/142) for more information on the next planned release.
 
@@ -224,7 +252,7 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
 * Removed confusing warning when not using native extenstions
 * Improved documentation
 
-### Release v0.7.0 (13 August 2014)
+## Release v0.7.0 (13 August 2014)
 
 * Merge the [atomic](https://github.com/ruby-concurrency/atomic) gem
   - Pure Ruby `MutexAtomic` atomic reference class
@@ -257,14 +285,14 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
 * Removed deprecated `Actor` class
 * Better support for Rubinius
 
-### Release v0.6.1 (14 June 2014)
+## Release v0.6.1 (14 June 2014)
 
 * Many improvements to `Concurrent::Actress`
 * Bug fixes to `Concurrent::RubyThreadPoolExecutor`
 * Fixed several brittle tests
 * Moved documentation to http://ruby-concurrency.github.io/concurrent-ruby/frames.html
 
-### Release v0.6.0 (25 May 2014)
+## Release v0.6.0 (25 May 2014)
 
 * Added `Concurrent::Observable` to encapsulate our thread safe observer sets
 * Improvements to new `Channel`
@@ -303,7 +331,7 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
 * First implementation of [new, high-performance](https://github.com/ruby-concurrency/concurrent-ruby/pull/49) `Channel`
 * `Actor` is deprecated in favor of new experimental actor implementation [#73](https://github.com/ruby-concurrency/concurrent-ruby/pull/73). To avoid namespace collision it is living in `Actress` namespace until `Actor` is removed in next release.
 
-### Release v0.5.0
+## Release v0.5.0
 
 This is the most significant release of this gem since its inception. This release includes many improvements and optimizations. It also includes several bug fixes. The major areas of focus for this release were:
 

data/README.md

@@ -9,39 +9,28 @@
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT)
 [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-devs%20%26%20users-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
 
-<table>
-  <tr>
-    <td align="left" valign="top">
-      <p>
-        Modern concurrency tools for Ruby. Inspired by
-        <a href="http://www.erlang.org/doc/reference_manual/processes.html">Erlang</a>,
-        <a href="http://clojure.org/concurrent_programming">Clojure</a>,
-        <a href="http://akka.io/">Scala</a>,
-        <a href="http://www.haskell.org/haskellwiki/Applications_and_libraries/Concurrency_and_parallelism#Concurrent_Haskell">Haskell</a>,
-        <a href="http://blogs.msdn.com/b/dsyme/archive/2010/02/15/async-and-parallel-design-patterns-in-f-part-3-agents.aspx">F#</a>,
-        <a href="http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx">C#</a>,
-        <a href="http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html">Java</a>,
-        and classic concurrency patterns.
-      </p>
-      <p>
-        The design goals of this gem are:
-        <ul>
-          <li>Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why</li>
-          <li>Remain free of external gem dependencies</li>
-          <li>Stay true to the spirit of the languages providing inspiration</li>
-          <li>But implement in a way that makes sense for Ruby</li>
-          <li>Keep the semantics as idiomatic Ruby as possible</li>
-          <li>Support features that make sense in Ruby</li>
-          <li>Exclude features that don't make sense in Ruby</li>
-          <li>Be small, lean, and loosely coupled</li>
-        </ul>
-      </p>
-    </td>
-    <td align="right" valign="top">
-      <img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/doc/logo/concurrent-ruby-logo-300x300.png"/>
-    </td>
-  </tr>
-</table>
+Modern concurrency tools for Ruby. Inspired by
+[Erlang](http://www.erlang.org/doc/reference_manual/processes.html),
+[Clojure](http://clojure.org/concurrent_programming),
+[Scala](http://akka.io/),
+[Haskell](http://www.haskell.org/haskellwiki/Applications_and_libraries/Concurrency_and_parallelism#Concurrent_Haskell),
+[F#](http://blogs.msdn.com/b/dsyme/archive/2010/02/15/async-and-parallel-design-patterns-in-f-part-3-agents.aspx),
+[C#](http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx),
+[Java](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html),
+and classic concurrency patterns.
+
+<img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/doc/logo/concurrent-ruby-logo-300x300.png" align="right" style="margin-left: 20px;" />
+
+The design goals of this gem are:
+
+* Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why
+* Remain free of external gem dependencies
+* Stay true to the spirit of the languages providing inspiration
+* But implement in a way that makes sense for Ruby
+* Keep the semantics as idiomatic Ruby as possible
+* Support features that make sense in Ruby
+* Exclude features that don't make sense in Ruby
+* Be small, lean, and loosely coupled
 
 ### Supported Ruby versions
 
@@ -127,13 +116,13 @@ These features are under active development and may change frequently. They are
 keep backward compatibility (there may also lack tests and documentation). Semantic versions will
 be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move to `concurrent-ruby` when final.
 
-* [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html):
-  Implements the Actor Model, where concurrent actors exchange messages.
-* [New Future Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/FutureShortcuts.html):
+* [Promises Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promises.html):
   Unified implementation of futures and promises which combines features of previous `Future`,
   `Promise`, `IVar`, `Event`, `dataflow`, `Delay`, and `TimerTask` into a single framework. It extensively uses the
   new synchronization layer to make all the features **non-blocking** and **lock-free**, with the exception of obviously blocking
   operations like `#wait`, `#value`. It also offers better performance.
+* [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html):
+  Implements the Actor Model, where concurrent actors exchange messages.
 * [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/Channel.html):
   Communicating Sequential Processes ([CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes)).
   Functionally equivalent to Go [channels](https://tour.golang.org/concurrency/2) with additional
@@ -141,15 +130,16 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
 * [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
 * [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
-* [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeStack.html)
+* [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LockFreeStack.html)
 
 #### Statuses:
 
 *Why are these not in core?*
 
+- **Promises Framework** - They are being finalized to be able to be moved to core. They'll deprecate old 
+  implementation.
 - **Actor** - Partial documentation and tests; depends on new future/promise framework; stability is good.
 - **Channel** - Brand new implementation; partial documentation and tests; stability is good.
-- **Future/Promise Framework** - API changes; partial documentation and tests; stability is good.
 - **LazyRegister** - Missing documentation and tests.
 - **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Need real world battle testing.
 
@@ -235,8 +225,8 @@ The best practice is to depend on `concurrent-ruby` and let users to decide if t
 
 ## Maintainers
 
+* [Petr Chalupa](https://github.com/pitr-ch) (lead maintainer)
 * [Jerry D'Antonio](https://github.com/jdantonio) (creator)
-* [Petr Chalupa](https://github.com/pitr-ch)
 * [Michele Della Torre](https://github.com/mighe)
 * [Chris Seaton](https://github.com/chrisseaton)
 * [Paweł Obrok](https://github.com/obrok)

data/lib/concurrent.rb

@@ -65,13 +65,13 @@ require 'concurrent/options'
 #   Object references in Ruby are mutable. This can lead to serious
 #   problems when the {#value} of an object is a mutable reference. Which
 #   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
-#   "primative" data type. Each instance can be configured with a few
+#   "primitive" data type. Each instance can be configured with a few
 #   options that can help protect the program from potentially dangerous
-#   operations. Each of these options can be optionally set when the oject
+#   operations. Each of these options can be optionally set when the object
 #   instance is created:
 #
 #   * `:dup_on_deref` When true the object will call the `#dup` method on
-#     the `value` object every time the `#value` methid is called
+#     the `value` object every time the `#value` method is called
 #     (default: false)
 #   * `:freeze_on_deref` When true the object will call the `#freeze`
 #     method on the `value` object every time the `#value` method is called

data/lib/concurrent/async.rb

@@ -34,7 +34,7 @@ module Concurrent
   # When an Erlang module implements the `gen_server` behavior it becomes
   # inherently asynchronous. The `start` or `start_link` function spawns a
   # process (similar to a thread but much more lightweight and efficient) and
-  # reurns the ID of the process. Using the process ID, other processes can
+  # returns the ID of the process. Using the process ID, other processes can
   # send messages to the `gen_server` via the `cast` and `call` methods. Unlike
   # Erlang's `gen_server`, however, `Async` classes do not support linking or
   # supervision trees.
@@ -142,7 +142,7 @@ module Concurrent
   # practice is to read the instance variable into a local variable at the start
   # of the method then update the instance variable at the *end* of the method.
   # This way, should an exception be raised during method execution the internal
-  # state of the boject will not have been changed.
+  # state of the object will not have been changed.
   #
   # ### Reader Attributes
   #

data/lib/concurrent/atom.rb

@@ -19,7 +19,7 @@ require 'concurrent/synchronization'
 #     the value will undergo frequent reads but only occasional, though complex,
 #     updates. Suitable when the result of an update must be known immediately.
 #   * *{Concurrent::AtomicReference}:* A simple object reference that can be
-#     atomically. Updates are synchronous but fast. Bast used when updates a
+#     atomically. Updates are synchronous but fast. Best used when updates a
 #     simple set operations. Not suitable when updates are complex.
 #     {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
 #     but optimized for the given data type.
@@ -37,6 +37,7 @@ require 'concurrent/synchronization'
 #     *coordinated*, *synchronous*, change of *many* stated. Used when multiple
 #     value must change together, in an all-or-nothing transaction.
 
+
 module Concurrent
 
   # Atoms provide a way to manage shared, synchronous, independent state.
@@ -61,7 +62,7 @@ module Concurrent
   #   set + [set[-2..-1].reduce{|sum,x| sum + x }]
   # end
   #
-  # # create an atom with aninitial value
+  # # create an atom with an initial value
   # atom = Concurrent::Atom.new(next_fibonacci)
   #
   # # send a few update requests
@@ -144,7 +145,7 @@ module Concurrent
     # @param [Object] args Zero or more arguments passed to the block.
     #
     # @yield [value, args] Calculates a new value for the atom based on the
-    #   current value and any supplied agruments.
+    #   current value and any supplied arguments.
     # @yieldparam value [Object] The current value of the atom.
     # @yieldparam args [Object] All arguments passed to the function, in order.
     # @yieldreturn [Object] The intended new value of the atom.

data/lib/concurrent/atomic/abstract_thread_local_var.rb

@@ -8,8 +8,17 @@ module Concurrent
   class AbstractThreadLocalVar
 
     # @!macro thread_local_var_method_initialize
-    def initialize(default = nil)
-      @default = default
+    def initialize(default = nil, &default_block)
+      if default && block_given?
+        raise ArgumentError, "Cannot use both value and block as default value"
+      end
+
+      if block_given?
+        @default_block = default_block
+      else
+        @default = default
+      end
+
       allocate_storage
     end
 
@@ -25,7 +34,15 @@ module Concurrent
 
     # @!macro thread_local_var_method_bind
     def bind(value, &block)
-      raise NotImplementedError
+      if block_given?
+        old_value = self.value
+        begin
+          self.value = value
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
     end
 
     protected
@@ -34,5 +51,14 @@ module Concurrent
     def allocate_storage
       raise NotImplementedError
     end
+
+    # @!visibility private
+    def default
+      if @default_block
+        self.value = @default_block.call
+      else
+        @default
+      end
+    end
   end
 end

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -129,5 +129,9 @@ module Concurrent
   #
   # @!macro atomic_fixnum_public_api
   class AtomicFixnum < AtomicFixnumImplementation
+    # @return [String] Short string representation.
+    def to_s
+      format '<#%s:0x%x value:%s>', self.class, object_id << 1, get
+    end
   end
 end

data/lib/concurrent/atomic/atomic_reference.rb

@@ -40,3 +40,10 @@ else
   class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
   end
 end
+
+class Concurrent::AtomicReference
+  # @return [String] Short string representation.
+  def to_s
+    format '<#%s:0x%x value:%s>', self.class, object_id << 1, get
+  end
+end

data/lib/concurrent/atomic/count_down_latch.rb

@@ -72,6 +72,29 @@ module Concurrent
   #   with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
   #
   # @!macro count_down_latch_public_api
+  # @example Waiter and Decrementer
+  #   latch = Concurrent::CountDownLatch.new(3)
+  #
+  #   waiter = Thread.new do
+  #     latch.wait()
+  #     puts ("Waiter released")
+  #   end
+  #
+  #   decrementer = Thread.new do
+  #     sleep(1)
+  #     latch.count_down
+  #     puts latch.count
+  #
+  #     sleep(1)
+  #     latch.count_down
+  #     puts latch.count
+  #
+  #     sleep(1)
+  #     latch.count_down
+  #     puts latch.count
+  #   end
+  #
+  #   [waiter, decrementer].each(&:join)
   class CountDownLatch < CountDownLatchImplementation
   end
 end

data/lib/concurrent/atomic/cyclic_barrier.rb

@@ -1,9 +1,29 @@
 require 'concurrent/synchronization'
+require 'concurrent/utility/native_integer'
 
 module Concurrent
 
   # A synchronization aid that allows a set of threads to all wait for each
   # other to reach a common barrier point.
+  # @example
+  #   barrier = Concurrent::CyclicBarrier.new(3)
+  #   jobs    = Array.new(3) { |i| -> { sleep i; p done: i } }
+  #   process = -> (i) do
+  #     # waiting to start at the same time
+  #     barrier.wait
+  #     # execute job
+  #     jobs[i].call
+  #     # wait for others to finish
+  #     barrier.wait
+  #   end
+  #   threads = 2.times.map do |i|
+  #     Thread.new(i, &process)
+  #   end
+  #
+  #   # use main as well
+  #   process.call 2
+  #
+  #   # here we can be sure that all jobs are processed  
   class CyclicBarrier < Synchronization::LockableObject
 
     # @!visibility private
@@ -18,9 +38,9 @@ module Concurrent
     #
     # @raise [ArgumentError] if `parties` is not an integer or is less than zero
     def initialize(parties, &block)
-      if !parties.is_a?(Fixnum) || parties < 1
-        raise ArgumentError.new('count must be in integer greater than or equal zero')
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds parties
+      Utility::NativeInteger.ensure_positive_and_no_zero parties
+
       super(&nil)
       synchronize { ns_initialize parties, &block }
     end