concurrent-ruby 0.7.0.rc2-java → 0.7.1-java

data/CHANGELOG.md

@@ -0,0 +1,138 @@
+## Current 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.
+
+* Added `flat_map` method to `Promise`
+* Added `zip` method to `Promise`
+* Fixed bug with logging in `Actor`
+* Improvements to `Promise` tests
+* Removed actor-experimental warning
+* Added an `IndirectImmediateExecutor` class
+* Allow disabling auto termination of global executors
+* Fix thread leaking in `ThreadLocalVar` (uses `Ref` gem on non-JRuby systems)
+* Fix thread leaking when pruning pure-Ruby thread pools
+* Prevent `Actor` from using an `ImmediateExecutor` (causes deadlock)
+* Added missing synchronizations to `TimerSet`
+* Fixed bug with return value of `Concurrent::Actor::Utils::Pool#ask`
+* Fixed timing bug in `TimerTask`
+* Fixed bug when creating a `JavaThreadPoolExecutor` with minimum pool size of zero
+* Removed confusing warning when not using native extenstions
+* Improved documentation
+
+### Release v0.7.0 (13 August 2014)
+
+* Merge the [atomic](https://github.com/ruby-concurrency/atomic) gem
+  - Pure Ruby `MutexAtomic` atomic reference class
+  - Platform native atomic reference classes `CAtomic`, `JavaAtomic`, and `RbxAtomic`
+  - Automated [build process](https://github.com/ruby-concurrency/rake-compiler-dev-box)
+  - Fat binary releases for [multiple platforms](https://rubygems.org/gems/concurrent-ruby/versions) including Windows (32/64), Linux (32/64), OS X (64-bit), Solaris (64-bit), and JRuby
+* C native `CAtomicBoolean`
+* C native `CAtomicFixnum`
+* Refactored intermittently failing tests
+* Added `dataflow!` and `dataflow_with!` methods to match `Future#value!` method
+* Better handling of timeout in `Agent`
+* Actor Improvements
+  - Fine-grained implementation using chain of behaviors. Each behavior is responsible for single aspect like: `Termination`, `Pausing`, `Linking`, `Supervising`, etc. Users can create custom Actors easily based on their needs.
+  - Supervision was added. `RestartingContext` will pause on error waiting on its supervisor to decide what to do next ( options are `:terminate!`, `:resume!`, `:reset!`, `:restart!`). Supervising behavior also supports strategies `:one_for_one` and `:one_for_all`.
+  - Linking was added to be able to monitor actor's events like: `:terminated`, `:paused`, `:restarted`, etc.
+  - Dead letter routing added. Rejected envelopes are collected in a configurable actor (default: `Concurrent::Actor.root.ask!(:dead_letter_routing)`)
+  - Old `Actor` class removed and replaced by new implementation previously called `Actress`. `Actress` was kept as an alias for `Actor` to keep compatibility.
+  - `Utils::Broadcast` actor which allows Publish–subscribe pattern.
+* More executors for managing serialized operations
+  - `SerializedExecution` mixin module
+  - `SerializedExecutionDelegator` for serializing *any* executor
+* Updated `Async` with serialized execution
+* Updated `ImmediateExecutor` and `PerThreadExecutor` with full executor service lifecycle
+* Added a `Delay` to root `Actress` initialization 
+* Minor bug fixes to thread pools
+* Refactored many intermittently failing specs
+* Removed Java interop warning `executor.rb:148 warning: ambiguous Java methods found, using submit(java.lang.Runnable)`
+* Fixed minor bug in `RubyCachedThreadPool` overflow policy
+* Updated tests to use [RSpec 3.0](http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3)
+* Removed deprecated `Actor` class
+* Better support for Rubinius
+
+### 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)
+
+* Added `Concurrent::Observable` to encapsulate our thread safe observer sets
+* Improvements to new `Channel`
+* Major improvements to `CachedThreadPool` and `FixedThreadPool`
+* Added `SingleThreadExecutor`
+* Added `Current::timer` function
+* Added `TimerSet` executor
+* Added `AtomicBoolean`
+* `ScheduledTask` refactoring
+* Pure Ruby and JRuby-optimized `PriorityQueue` classes
+* Updated `Agent` behavior to more closely match Clojure
+* Observer sets support block callbacks to the `add_observer` method
+* New algorithm for thread creation in `RubyThreadPoolExecutor`
+* Minor API updates to `Event`
+* Rewritten `TimerTask` now an `Executor` instead of a `Runnable`
+* Fixed many brittle specs
+* Renamed `FixedThreadPool` and `CachedThreadPool` to `RubyFixedThreadPool` and `RubyCachedThreadPool`
+* Created JRuby optimized `JavaFixedThreadPool` and `JavaCachedThreadPool`
+* Consolidated fixed thread pool tests into `spec/concurrent/fixed_thread_pool_shared.rb` and  `spec/concurrent/cached_thread_pool_shared.rb`
+* `FixedThreadPool` now subclasses `RubyFixedThreadPool` or `JavaFixedThreadPool` as appropriate
+* `CachedThreadPool` now subclasses `RubyCachedThreadPool` or `JavaCachedThreadPool` as appropriate
+* New `Delay` class
+* `Concurrent::processor_count` helper function
+* New `Async` module
+* Renamed `NullThreadPool` to `PerThreadExecutor`
+* Deprecated `Channel` (we are planning a new implementation based on [Go](http://golangtutorials.blogspot.com/2011/06/channels-in-go.html))
+* Added gem-level [configuration](http://robots.thoughtbot.com/mygem-configure-block)
+* Deprecated `$GLOBAL_THREAD_POOL` in lieu of gem-level configuration
+* Removed support for Ruby [1.9.2](https://www.ruby-lang.org/en/news/2013/12/17/maintenance-of-1-8-7-and-1-9-2/)
+* New `RubyThreadPoolExecutor` and `JavaThreadPoolExecutor` classes
+* All thread pools now extend the appropriate thread pool executor classes
+* All thread pools now support `:overflow_policy` (based on Java's [reject policies](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html))
+* Deprecated `UsesGlobalThreadPool` in lieu of explicit `:executor` option (dependency injection) on `Future`, `Promise`, and `Agent`
+* Added `Concurrent::dataflow_with(executor, *inputs)` method to support executor dependency injection for dataflow
+* Software transactional memory with `TVar` and `Concurrent::atomically`
+* 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
+
+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:
+
+* Stability improvements on Ruby versions with thread-level parallelism ([JRuby](http://jruby.org/) and [Rubinius](http://rubini.us/))
+* Creation of new low-level concurrency abstractions
+* Internal refactoring to use the new low-level abstractions
+
+Most of these updates had no effect on the gem API. There are a few notable exceptions which were unavoidable. Please read the [release notes](API-Updates-in-v0.5.0) for more information.
+
+Specific changes include:
+
+* New class `IVar`
+* New class `MVar`
+* New class `ThreadLocalVar`
+* New class `AtomicFixnum`
+* New class method `dataflow`
+* New class `Condition`
+* New class `CountDownLatch`
+* New class `DependencyCounter`
+* New class `SafeTaskExecutor`
+* New class `CopyOnNotifyObserverSet`
+* New class `CopyOnWriteObserverSet`
+* `Future` updated with `execute` API
+* `ScheduledTask` updated with `execute` API
+* New `Promise` API
+* `Future` now extends `IVar`
+* `Postable#post?` now returns an `IVar`
+* Thread safety fixes to `Dereferenceable`
+* Thread safety fixes to `Obligation`
+* Thread safety fixes to `Supervisor`
+* Thread safety fixes to `Event`
+* Various other thread safety (race condition) fixes
+* Refactored brittle tests
+* Implemented pending tests
+* Added JRuby and Rubinius as Travis CI build targets
+* Added [CodeClimate](https://codeclimate.com/) code review
+* Improved YARD documentation

data/README.md

@@ -1,5 +1,5 @@
 # Concurrent Ruby
-[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.png)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Coverage Status](https://coveralls.io/repos/ruby-concurrency/concurrent-ruby/badge.png)](https://coveralls.io/r/ruby-concurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.png)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.png)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.png)](https://gemnasium.com/ruby-concurrency/concurrent-ruby) [![Gitter chat](https://badges.gitter.im/ruby-concurrency/concurrent-ruby.png)](https://gitter.im/ruby-concurrency/concurrent-ruby)
+[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.svg)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Coverage Status](https://img.shields.io/coveralls/ruby-concurrency/concurrent-ruby/master.svg)](https://coveralls.io/r/ruby-concurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.svg)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.svg)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.svg)](https://gemnasium.com/ruby-concurrency/concurrent-ruby) [![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT) [![Gitter chat](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
 
 <table>
   <tr>
@@ -30,12 +30,96 @@
       </p>
     </td>
     <td align="right" valign="top">
-      <img src="https://raw.githubusercontent.com/wiki/ruby-concurrency/concurrent-ruby/logo/concurrent-ruby-logo-300x300.png"/>
+      <img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/doc/logo/concurrent-ruby-logo-300x300.png"/>
     </td>
   </tr>
 </table>
 
-## Install
+### Supported Ruby versions
+
+MRI 1.9.3, 2.0, 2.1, JRuby (1.9 mode), and Rubinius 2.x are supported.
+Although native code is used for performance optimizations on some platforms, all functionality
+is available in pure Ruby. This gem should be fully compatible with any interpreter that is
+compliant with Ruby 1.9.3 or newer.
+
+## Features & Documentation
+
+We have a roadmap guiding our work toward the [v1.0.0 release](https://github.com/ruby-concurrency/concurrent-ruby/wiki/v1.0-Roadmap).
+
+The primary site for documentation is the automatically generated [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html)
+
+We also have a [mailing list](http://groups.google.com/group/concurrent-ruby).
+
+This library contains a variety of concurrency abstractions at high and low levels. One of the high-level abstractions is likely to meet most common needs. 
+
+### High-level, general-purpose asynchronous concurrency abstractions
+
+* [Actor](./doc/actor/main.md): Implements the Actor Model, where concurrent actors exchange messages. 
+* [Agent](./doc/agent.md): A single atomic value that represents an identity.
+* [Async](./doc/async.md): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
+* [Future](./doc/future.md): An asynchronous operation that produces a value.
+  * [Dataflow](./doc/dataflow.md): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+* [Promise](./doc/promise.md): Similar to Futures, with more features. 
+* [ScheduledTask](./doc/scheduled_task.md): Like a Future scheduled for a specific future time. 
+* [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals. 
+
+
+### Java-inspired ThreadPools and other executors
+
+* See [ThreadPool](./doc/thread_pools.md) overview, which also contains a list of other Executors available.
+
+### Thread-safe Observers
+
+* [Concurrent::Observable](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Observable.html) mixin module
+* [CopyOnNotifyObserverSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CopyOnNotifyObserverSet.html)
+* [CopyOnWriteObserverSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CopyOnWriteObserverSet.html)
+
+### Thread synchronization classes and algorithms
+Lower-level abstractions mainly used as building blocks. 
+
+* [condition](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Condition.html)
+* [countdown latch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html)
+* [cyclic barrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
+* [event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
+* [exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
+* [timeout](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timeout-class_method)
+* [timer](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timer-class_method)
+
+### Thread-safe variables
+Lower-level abstractions mainly used as building blocks. 
+
+* [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html)
+* [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html)
+* AtomicReference (no docs currently available, check source)
+* [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar)
+* [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar)
+* [thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
+* [software transactional memory](./doc/tvar.md) (TVar)
+
+
+
+## Installing and Building
+
+This gem includes several platform-specific optimizations. To reduce the possibility of
+compilation errors, we provide pre-compiled gem packages for several platforms as well
+as a pure-Ruby build. Installing the gem should be no different than installing any other
+Rubygems-hosted gem. Rubygems will automatically detect your platform and install the
+appropriate pre-compiled build. You should never see Rubygems attempt to compile the gem
+on installation. Additionally, to ensure compatability with the largest possible number
+of Ruby interpreters, the C extensions will *never* load under any Ruby other than MRI,
+even when installed.
+
+The following gem builds will be built at every release:
+
+* concurrent-ruby-x.y.z.gem (pure Ruby)
+* concurrent-ruby-x.y.z-java.gem (JRuby)
+* concurrent-ruby-x.y.z-x86-linux.gem (Linux 32-bit)
+* concurrent-ruby-x.y.z-x86_64-linux.gem (Linux 64-bit)
+* concurrent-ruby-x.y.z-x86-mingw32.gem (Windows 32-bit)
+* concurrent-ruby-x.y.z-x64-mingw32.gem (Windows 64-bit)
+* concurrent-ruby-x.y.z-x86-solaris-2.11.gem (Solaris)
+
+### Installing
 
 ```shell
 gem install concurrent-ruby
@@ -49,86 +133,31 @@ gem 'concurrent-ruby'
 
 and run `bundle install` from your shell.
 
-_NOTE: There is an old gem from 2007 called "concurrent" that does not appear to be under active development. That isn't us. Please do not run* `gem install concurrent`*. It is not the droid you are looking for._
+### Building
 
-## Features & Documentation
+Because we provide pre-compiled gem builds, users should never need to build the gem manually.
+The build process for this gem is completely automated using open source tools. All of
+the automation components are available in the [ruby-concurrency/rake-compiler-dev-box](https://github.com/ruby-concurrency/rake-compiler-dev-box)
+GitHub repository.
 
-Please see the [Concurrent Ruby Wiki](https://github.com/ruby-concurrency/concurrent-ruby/wiki)
-or the [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html)
-for more information or join our [mailing list](http://groups.google.com/group/concurrent-ruby).
-
-There are many concurrency abstractions in this library. These abstractions can be broadly categorized
-into several general groups:
-
-* Asynchronous concurrency abstractions including
-  [Async](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Async),
-  [Agent](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Agent),
-  [Future](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Future),
-  [Promise](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Promise),
-  [ScheduledTask](https://github.com/ruby-concurrency/concurrent-ruby/wiki/ScheduledTask),
-  and [TimerTask](https://github.com/ruby-concurrency/concurrent-ruby/wiki/TimerTask) 
-* Thread-safe variables including [M-Structures](https://github.com/ruby-concurrency/concurrent-ruby/wiki/MVar-(M-Structure)),
-  [I-Structures](https://github.com/ruby-concurrency/concurrent-ruby/wiki/IVar-(I-Structure)),
-  [thread-local variables](https://github.com/ruby-concurrency/concurrent-ruby/wiki/ThreadLocalVar),
-  atomic counters, and [software transactional memory](https://github.com/ruby-concurrency/concurrent-ruby/wiki/TVar-(STM))
-* Thread synchronization classes and algorithms including [dataflow](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Dataflow), 
-  timeout, condition, countdown latch, dependency counter, and event
-* Java-inspired [thread pools](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Thread%20Pools)
-* New fast light-weighted [Actor model](http://ruby-concurrency.github.io/concurrent-ruby/frames.html#!Concurrent/Actress.html) implementation. 
-* And many more...
-
-### Semantic Versioning
-
-This gem adheres to the rules of [semantic versioning](http://semver.org/).
+This gem will compile native C code under MRI and native Java code under JRuby. It is
+also possible to build a pure-Ruby version. All builds have identical functionality.
+The only difference is performance. Additionally, pure-Ruby classes are always available,
+even when using the native optimizations. Please see the [documentation](http://ruby-concurrency.github.io/concurrent-ruby/)
+for more details.
 
-### Supported Ruby versions
+To build and package the gem using MRI or JRuby, install the necessary build dependencies and run:
+
+```shell
+bundle exec rake compile
+bundle exec rake build
+```
+
+To build and package a pure-Ruby gem, on *any* platform and interpreter
+(including MRI and JRuby), run:
 
-MRI 1.9.3, 2.0, 2.1, JRuby (1.9 mode), and Rubinius 2.x.
-This library is pure Ruby and has no gem dependencies.
-It should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
-
-### Examples
-
-Many more code examples can be found in the documentation for each class (linked above).
-This one simple example shows some of the power of this gem.
-
-```ruby    
-require 'concurrent'
-require 'thread'   # for Queue
-require 'open-uri' # for open(uri)
-
-class Ticker
-  def get_year_end_closing(symbol, year)
-    uri = "http://ichart.finance.yahoo.com/table.csv?s=#{symbol}&a=11&b=01&c=#{year}&d=11&e=31&f=#{year}&g=m"
-    data = open(uri) {|f| f.collect{|line| line.strip } }
-    data[1].split(',')[4].to_f
-  end
-end
-
-# Future
-price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013) }
-price.state #=> :pending
-sleep(1)    # do other stuff
-price.value #=> 63.65
-price.state #=> :fulfilled
-
-# Promise
-prices = Concurrent::Promise.new{ puts Ticker.new.get_year_end_closing('AAPL', 2013) }.
-           then{ puts Ticker.new.get_year_end_closing('MSFT', 2013) }.
-           then{ puts Ticker.new.get_year_end_closing('GOOG', 2013) }.
-           then{ puts Ticker.new.get_year_end_closing('AMZN', 2013) }.execute
-prices.state #=> :pending
-sleep(1)     # do other stuff
-#=> 561.02
-#=> 37.41
-#=> 1120.71
-#=> 398.79
-
-# ScheduledTask
-task = Concurrent::ScheduledTask.execute(2){ Ticker.new.get_year_end_closing('INTC', 2013) }
-task.state #=> :pending
-sleep(3)   # do other stuff
-task.value #=> 25.96
+```shell
+BUILD_PURE_RUBY='true' bundle exec rake build
 ```
 
 ## Maintainers
@@ -139,22 +168,6 @@ task.value #=> 25.96
 * [Lucas Allan](https://github.com/lucasallan)
 * [Petr Chalupa](https://github.com/pitr-ch)
 
-### Contributors
-
-* [Bill Dueber](https://github.com/billdueber)
-* [Brian Shirai](https://github.com/brixen)
-* [Chip Miller](https://github.com/chip-miller)
-* [Giuseppe Capizzi](https://github.com/gcapizzi)
-* [Jamie Hodge](https://github.com/jamiehodge)
-* [Justin Lambert](https://github.com/mastfish)
-* [Larry Lv](https://github.com/larrylv)
-* [Maxim Chechel](https://github.com/maximchick)
-* [Ravil Bayramgalin](https://github.com/brainopia)
-* [René Föhring](https://github.com/rrrene)
-* [Shane Wilton](https://github.com/ShaneWilton)
-* [sheaney](https://github.com/sheaney)
-* [Zander Hill](https://github.com/zph)
-
 ### Contributing
 
 1. Fork it

data/lib/concurrent/actor.rb

@@ -5,11 +5,17 @@ require 'concurrent/logging'
 require 'concurrent/atomic/synchronization'
 
 module Concurrent
-  # TODO https://github.com/celluloid/celluloid/wiki/Supervision-Groups
+  # TODO https://github.com/celluloid/celluloid/wiki/Supervision-Groups ?
+  # TODO Remote actors using DRb
+  # TODO IO interoperation
+  # TODO un/become
 
   # TODO doc
   # - what happens if I try to supervise using a normal Context?
-
+  # - how to change behaviours
+  # - how to implement custom restarting?
+  # - pool for io operations using different executor
+  # - document guaranteed ordering
 
   # {include:file:doc/actor/main.md}
   module Actor
@@ -26,7 +32,7 @@ module Concurrent
 
     require 'concurrent/actor/default_dead_letter_handler'
     require 'concurrent/actor/root'
-    require 'concurrent/actor/ad_hoc'
+    require 'concurrent/actor/utils'
 
     # @return [Reference, nil] current executing actor if any
     def self.current
@@ -61,13 +67,10 @@ module Concurrent
     # @param args see {.spawn_optionify}
     # @return [Reference] never the actual actor
     def self.spawn(*args, &block)
-      experimental_acknowledged? or
-          warn '[EXPERIMENTAL] A full release of `Actor`, is expected in the 0.7.0 release.'
-
       if Actor.current
         Core.new(spawn_optionify(*args).merge(parent: Actor.current), &block).reference
       else
-        root.ask([:spawn, spawn_optionify(*args), block]).value
+        root.ask([:spawn, spawn_optionify(*args), block]).value!
       end
     end
 
@@ -77,7 +80,7 @@ module Concurrent
     end
 
     # @overload spawn_optionify(context_class, name, *args)
-    #   @param [Context] context_class to be spawned
+    #   @param [AbstractContext] context_class to be spawned
     #   @param [String, Symbol] name of the instance, it's used to generate the {Core#path} of the actor
     #   @param args for context_class instantiation
     # @overload spawn_optionify(opts)
@@ -94,11 +97,7 @@ module Concurrent
 
     # call this to disable experimental warning
     def self.i_know_it_is_experimental!
-      @experimental_acknowledged = true
-    end
-
-    def self.experimental_acknowledged?
-      !!@experimental_acknowledged
+      warn 'Method Actor.i_know_it_is_experimental! is deprecated. The Actors are no longer experimental.'
     end
   end
 end

data/lib/concurrent/actor/behaviour/errors_on_unknown_message.rb

@@ -1,7 +1,7 @@
 module Concurrent
   module Actor
     module Behaviour
-      # Simply fails when message arrives here.
+      # Simply fails when message arrives here. It's usually the last behaviour.
       class ErrorsOnUnknownMessage < Abstract
         def on_envelope(envelope)
           raise UnknownMessage, envelope

data/lib/concurrent/actor/behaviour/executes_context.rb

@@ -1,7 +1,7 @@
 module Concurrent
   module Actor
     module Behaviour
-      # Delegates messages nad events to {AbstractContext} instance
+      # Delegates messages and events to {AbstractContext} instance
       class ExecutesContext < Abstract
         def on_envelope(envelope)
           context.on_envelope envelope