concurrent-ruby 1.0.5 → 1.1.0.pre2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (107) hide show
  1. checksums.yaml +5 -5
  2. data/CHANGELOG.md +44 -0
  3. data/Gemfile +39 -0
  4. data/{LICENSE.txt → LICENSE.md} +2 -0
  5. data/README.md +203 -105
  6. data/Rakefile +279 -0
  7. data/ext/concurrent-ruby/ConcurrentRubyService.java +17 -0
  8. data/ext/concurrent-ruby/com/concurrent_ruby/ext/AtomicReferenceLibrary.java +175 -0
  9. data/ext/concurrent-ruby/com/concurrent_ruby/ext/JRubyMapBackendLibrary.java +248 -0
  10. data/ext/concurrent-ruby/com/concurrent_ruby/ext/JavaAtomicBooleanLibrary.java +93 -0
  11. data/ext/concurrent-ruby/com/concurrent_ruby/ext/JavaAtomicFixnumLibrary.java +113 -0
  12. data/ext/concurrent-ruby/com/concurrent_ruby/ext/JavaSemaphoreLibrary.java +159 -0
  13. data/ext/concurrent-ruby/com/concurrent_ruby/ext/SynchronizationLibrary.java +304 -0
  14. data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/ConcurrentHashMap.java +31 -0
  15. data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/ConcurrentHashMapV8.java +3863 -0
  16. data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/LongAdder.java +203 -0
  17. data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/Striped64.java +342 -0
  18. data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/nounsafe/ConcurrentHashMapV8.java +3800 -0
  19. data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/nounsafe/LongAdder.java +204 -0
  20. data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/nounsafe/Striped64.java +291 -0
  21. data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166y/ThreadLocalRandom.java +199 -0
  22. data/lib/concurrent-ruby.rb +1 -0
  23. data/lib/concurrent.rb +24 -20
  24. data/lib/concurrent/agent.rb +7 -7
  25. data/lib/concurrent/array.rb +59 -32
  26. data/lib/concurrent/async.rb +4 -4
  27. data/lib/concurrent/atom.rb +9 -9
  28. data/lib/concurrent/atomic/atomic_boolean.rb +24 -20
  29. data/lib/concurrent/atomic/atomic_fixnum.rb +27 -23
  30. data/lib/concurrent/atomic/atomic_markable_reference.rb +164 -0
  31. data/lib/concurrent/atomic/atomic_reference.rb +176 -33
  32. data/lib/concurrent/atomic/count_down_latch.rb +6 -6
  33. data/lib/concurrent/atomic/cyclic_barrier.rb +1 -1
  34. data/lib/concurrent/atomic/event.rb +1 -1
  35. data/lib/concurrent/atomic/java_count_down_latch.rb +6 -5
  36. data/lib/concurrent/atomic/mutex_count_down_latch.rb +1 -0
  37. data/lib/concurrent/atomic/read_write_lock.rb +2 -1
  38. data/lib/concurrent/atomic/reentrant_read_write_lock.rb +3 -1
  39. data/lib/concurrent/atomic/semaphore.rb +8 -8
  40. data/lib/concurrent/atomic/thread_local_var.rb +7 -7
  41. data/lib/concurrent/atomic_reference/mutex_atomic.rb +3 -8
  42. data/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb +1 -1
  43. data/lib/concurrent/atomics.rb +0 -43
  44. data/lib/concurrent/collection/lock_free_stack.rb +158 -0
  45. data/lib/concurrent/collection/map/atomic_reference_map_backend.rb +3 -3
  46. data/lib/concurrent/collection/map/non_concurrent_map_backend.rb +1 -2
  47. data/lib/concurrent/collection/non_concurrent_priority_queue.rb +29 -29
  48. data/lib/concurrent/concern/dereferenceable.rb +1 -1
  49. data/lib/concurrent/concern/logging.rb +6 -1
  50. data/lib/concurrent/concern/observable.rb +7 -7
  51. data/lib/concurrent/concurrent_ruby.jar +0 -0
  52. data/lib/concurrent/configuration.rb +1 -6
  53. data/lib/concurrent/constants.rb +1 -1
  54. data/lib/concurrent/dataflow.rb +2 -1
  55. data/lib/concurrent/delay.rb +9 -7
  56. data/lib/concurrent/exchanger.rb +13 -21
  57. data/lib/concurrent/executor/abstract_executor_service.rb +2 -2
  58. data/lib/concurrent/executor/cached_thread_pool.rb +1 -1
  59. data/lib/concurrent/executor/executor_service.rb +15 -15
  60. data/lib/concurrent/executor/fixed_thread_pool.rb +18 -18
  61. data/lib/concurrent/executor/java_thread_pool_executor.rb +10 -7
  62. data/lib/concurrent/executor/single_thread_executor.rb +2 -2
  63. data/lib/concurrent/executor/thread_pool_executor.rb +6 -6
  64. data/lib/concurrent/executor/timer_set.rb +1 -1
  65. data/lib/concurrent/future.rb +4 -1
  66. data/lib/concurrent/hash.rb +53 -30
  67. data/lib/concurrent/ivar.rb +5 -6
  68. data/lib/concurrent/map.rb +20 -25
  69. data/lib/concurrent/maybe.rb +1 -1
  70. data/lib/concurrent/mutable_struct.rb +15 -14
  71. data/lib/concurrent/mvar.rb +2 -2
  72. data/lib/concurrent/promise.rb +53 -21
  73. data/lib/concurrent/promises.rb +1936 -0
  74. data/lib/concurrent/re_include.rb +58 -0
  75. data/lib/concurrent/set.rb +66 -0
  76. data/lib/concurrent/settable_struct.rb +1 -0
  77. data/lib/concurrent/synchronization.rb +4 -5
  78. data/lib/concurrent/synchronization/abstract_lockable_object.rb +5 -5
  79. data/lib/concurrent/synchronization/abstract_struct.rb +6 -4
  80. data/lib/concurrent/synchronization/lockable_object.rb +6 -6
  81. data/lib/concurrent/synchronization/{mri_lockable_object.rb → mutex_lockable_object.rb} +19 -14
  82. data/lib/concurrent/synchronization/object.rb +8 -4
  83. data/lib/concurrent/synchronization/truffleruby_object.rb +46 -0
  84. data/lib/concurrent/synchronization/volatile.rb +11 -9
  85. data/lib/concurrent/thread_safe/util/data_structures.rb +55 -0
  86. data/lib/concurrent/thread_safe/util/striped64.rb +9 -4
  87. data/lib/concurrent/timer_task.rb +5 -2
  88. data/lib/concurrent/tuple.rb +1 -1
  89. data/lib/concurrent/tvar.rb +2 -2
  90. data/lib/concurrent/utility/at_exit.rb +1 -1
  91. data/lib/concurrent/utility/engine.rb +2 -2
  92. data/lib/concurrent/utility/monotonic_time.rb +3 -3
  93. data/lib/concurrent/utility/native_extension_loader.rb +31 -33
  94. data/lib/concurrent/utility/processor_counter.rb +0 -2
  95. data/lib/concurrent/version.rb +2 -2
  96. metadata +35 -21
  97. data/lib/concurrent/atomic_reference/concurrent_update_error.rb +0 -8
  98. data/lib/concurrent/atomic_reference/direct_update.rb +0 -81
  99. data/lib/concurrent/atomic_reference/jruby+truffle.rb +0 -2
  100. data/lib/concurrent/atomic_reference/jruby.rb +0 -16
  101. data/lib/concurrent/atomic_reference/rbx.rb +0 -22
  102. data/lib/concurrent/atomic_reference/ruby.rb +0 -32
  103. data/lib/concurrent/edge.rb +0 -26
  104. data/lib/concurrent/lazy_register.rb +0 -81
  105. data/lib/concurrent/synchronization/truffle_lockable_object.rb +0 -9
  106. data/lib/concurrent/synchronization/truffle_object.rb +0 -31
  107. data/lib/concurrent/thread_safe/util/array_hash_rbx.rb +0 -30
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
- SHA1:
3
- metadata.gz: c2ef80367a4e0135992f3f9ca212bf6a32093bf2
4
- data.tar.gz: 435bf341ed840ee101e920819d6cb69c942223f1
2
+ SHA256:
3
+ metadata.gz: a9eff851dc1c1194d74471f51e804151e6523be1af22c681393518897d8723e7
4
+ data.tar.gz: 97aea57e3c31de3e0a927b07b5bbae7a5b2859537fe959f08d045fadc86d818a
5
5
  SHA512:
6
- metadata.gz: 88d799188af8df8c6f5fdab76e88207dd573815528f75f8739738256a82b831e8beab1b5991ec8554f073f8fc212d357c657306fb0b0f2f88810b7d3ba16efaa
7
- data.tar.gz: f2b6da535200eac3c255fb6b6e552fe0cff22935d85b7de03337e52383a81adc22bb6236cabf3757fe4632cfc07b0c33ef658c7ba95278dc41c3af2a40848d13
6
+ metadata.gz: ee74332b245d576afd75179edf7d37e2d815e0f24afe157e9b76189c7275e60a8edc348646d659c5d631e73fa5382a57a94ec82c6b4bb909a993f86b45677192
7
+ data.tar.gz: d21e2f11e2c3f9090cbb4e7dada48cd64d3eb3a9c7588417b6e52975ebe0a0f8fafc612695c46cd58f94389c7597800c038a57f89fa70db936493b007890d1e7
@@ -1,3 +1,47 @@
1
+ ## Current
2
+
3
+ ## Release v1.1.0.pre1, edge v0.4.0.pre1 (15 Aug 2018)
4
+
5
+ concurrent-ruby:
6
+
7
+ * [Promises](http://ruby-concurrency.github.io/concurrent-ruby/1.1.0/Concurrent/Promises.html)
8
+ are moved from `concurrent-ruby-edge` to `concurrent-ruby`
9
+ * Add support for TruffleRuby
10
+ * (#734) Fix Array/Hash/Set construction broken on TruffleRuby
11
+ * AtomicReference fixed
12
+ * CI stabilization
13
+ * remove sharp dependency edge -> core
14
+ * remove warnings
15
+ * documentation updates
16
+ * Exchanger is no longer documented as edge since it was already available in
17
+ `concurrent-ruby`
18
+ * (#644) Fix Map#each and #each_pair not returning enumerator outside of MRI
19
+ * (#659) Edge promises fail during error handling
20
+ * (#741) Raise on recursive Delay#value call
21
+ * (#727) #717 fix global IO executor on JRuby
22
+ * (#740) Drop support for CRuby 1.9, JRuby 1.7, Rubinius.
23
+ * (#737) Move AtomicMarkableReference out of Edge
24
+ * (#708) Prefer platform specific memory barriers
25
+ * (#735) Fix wrong expected exception in channel spec assertion
26
+ * (#729) Allow executor option in `Promise#then`
27
+ * (#725) fix timeout check to use timeout_interval
28
+ * (#719) update engine detection
29
+ * (#660) Add specs for Promise#zip/Promise.zip ordering
30
+ * (#654) Promise.zip execution changes
31
+ * (#666) Add thread safe set implementation
32
+ * (#651) #699 #to_s, #inspect should not output negative object IDs.
33
+ * (#685) Avoid RSpec warnings about raise_error
34
+ * (#680) Avoid RSpec monkey patching, persist spec results locally, use RSpec
35
+ v3.7.0
36
+ * (#665) Initialize the monitor for new subarrays on Rubinius
37
+ * (#661) Fix error handling in edge promises
38
+
39
+ concurrent-ruby-edge:
40
+
41
+ * (#659) Edge promises fail during error handling
42
+ * Edge files clearly separated in `lib-edge`
43
+ * added ReInclude
44
+
1
45
  ## Release v1.0.5, edge v0.3.1 (26 Feb 2017)
2
46
 
3
47
  concurrent-ruby:
data/Gemfile ADDED
@@ -0,0 +1,39 @@
1
+ source 'https://rubygems.org'
2
+
3
+ require_relative 'lib/concurrent/version'
4
+
5
+ no_path = ENV['NO_PATH']
6
+ options = no_path ? {} : { path: '.' }
7
+
8
+ gem 'concurrent-ruby', Concurrent::VERSION, options
9
+ gem 'concurrent-ruby-edge', Concurrent::EDGE_VERSION, options
10
+ gem 'concurrent-ruby-ext', Concurrent::VERSION, options.merge(platform: :mri)
11
+
12
+ group :development do
13
+ gem 'rake', '~> 12.0'
14
+ gem 'rake-compiler', '~> 1.0'
15
+ gem 'rake-compiler-dock', '~> 0.6.0'
16
+ gem 'pry', '~> 0.11', platforms: :mri
17
+ end
18
+
19
+ group :documentation, optional: true do
20
+ gem 'yard', '~> 0.9.0', :require => false
21
+ gem 'redcarpet', '~> 3.0', platforms: :mri # understands github markdown
22
+ gem 'md-ruby-eval', '~> 0.2'
23
+ end
24
+
25
+ group :testing do
26
+ gem 'rspec', '~> 3.7'
27
+ gem 'timecop', '~> 0.7.4'
28
+ end
29
+
30
+ # made opt-in since it will not install on jruby 1.7
31
+ group :coverage, optional: !ENV['COVERAGE'] do
32
+ gem 'simplecov', '~> 0.10.0', :require => false
33
+ gem 'coveralls', '~> 0.8.2', :require => false
34
+ end
35
+
36
+ group :benchmarks, optional: true do
37
+ gem 'benchmark-ips', '~> 2.7'
38
+ gem 'bench9000'
39
+ end
@@ -1,3 +1,4 @@
1
+ ```
1
2
  Copyright (c) Jerry D'Antonio -- released under the MIT license.
2
3
 
3
4
  http://www.opensource.org/licenses/mit-license.php
@@ -19,3 +20,4 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
20
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
21
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21
22
  THE SOFTWARE.
23
+ ```
data/README.md CHANGED
@@ -3,9 +3,6 @@
3
3
  [![Gem Version](https://badge.fury.io/rb/concurrent-ruby.svg)](http://badge.fury.io/rb/concurrent-ruby)
4
4
  [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby)
5
5
  [![Build status](https://ci.appveyor.com/api/projects/status/iq8aboyuu3etad4w?svg=true)](https://ci.appveyor.com/project/rubyconcurrency/concurrent-ruby)
6
- [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.svg)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby)
7
- [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.svg)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby)
8
- [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.svg)](https://gemnasium.com/ruby-concurrency/concurrent-ruby)
9
6
  [![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT)
10
7
  [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-devs%20%26%20users-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
11
8
 
@@ -19,129 +16,223 @@ Modern concurrency tools for Ruby. Inspired by
19
16
  [Java](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html),
20
17
  and classic concurrency patterns.
21
18
 
22
- <img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/doc/logo/concurrent-ruby-logo-300x300.png" align="right" style="margin-left: 20px;" />
19
+ <img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/docs-source/logo/concurrent-ruby-logo-300x300.png" align="right" style="margin-left: 20px;" />
23
20
 
24
21
  The design goals of this gem are:
25
22
 
26
- * Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why
27
- * Remain free of external gem dependencies
28
- * Stay true to the spirit of the languages providing inspiration
29
- * But implement in a way that makes sense for Ruby
30
- * Keep the semantics as idiomatic Ruby as possible
31
- * Support features that make sense in Ruby
32
- * Exclude features that don't make sense in Ruby
33
- * Be small, lean, and loosely coupled
34
-
35
- ### Supported Ruby versions
36
-
37
- MRI 1.9.3, 2.0 and above, JRuby 1.7x in 1.9 mode, JRuby 9000, and Rubinius 2.x are supported.
38
- This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
39
- Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs is supported.
23
+ * Be an 'unopinionated' toolbox that provides useful utilities without debating which is better
24
+ or why
25
+ * Remain free of external gem dependencies
26
+ * Stay true to the spirit of the languages providing inspiration
27
+ * But implement in a way that makes sense for Ruby
28
+ * Keep the semantics as idiomatic Ruby as possible
29
+ * Support features that make sense in Ruby
30
+ * Exclude features that don't make sense in Ruby
31
+ * Be small, lean, and loosely coupled
32
+ * Thread-safety
33
+ * Backward compatibility
34
+
35
+ ## Contributing
36
+
37
+ **This gem depends on
38
+ [contributions](https://github.com/ruby-concurrency/concurrent-ruby/graphs/contributors) and we
39
+ appreciate your help. Would you like to contribute? Great! Have a look at
40
+ [issues with `looking-for-contributor` label](https://github.com/ruby-concurrency/concurrent-ruby/issues?q=is%3Aissue+is%3Aopen+label%3Alooking-for-contributor).** And if you pick something up let us know on the issue.
40
41
 
41
42
  ## Thread Safety
42
43
 
43
- *Concurrent Ruby makes the strongest thread safety guarantees of any Ruby concurrency library. We are the only library with a published [memory model](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/doc/synchronization.md) which provides consistent behavior and guarantees on all three of the main Ruby interpreters (MRI/CRuby, JRuby, and Rubinius).*
44
+ *Concurrent Ruby makes one of the strongest thread safety guarantees of any Ruby concurrency
45
+ library, providing consistent behavior and guarantees on all three of the main Ruby interpreters
46
+ (MRI/CRuby, JRuby, and Rubinius).*
47
+
48
+ Every abstraction in this library is thread safe. Specific thread safety guarantees are documented
49
+ with each abstraction.
44
50
 
45
- Every abstraction in this library is thread safe. Similarly, all are deadlock free and many are fully lock free. Specific thread safety guarantees are documented with each abstraction.
51
+ It is critical to remember, however, that Ruby is a language of mutable references. *No*
52
+ concurrency library for Ruby can ever prevent the user from making thread safety mistakes (such as
53
+ sharing a mutable object between threads and modifying it on both threads) or from creating
54
+ deadlocks through incorrect use of locks. All the library can do is provide safe abstractions which
55
+ encourage safe practices. Concurrent Ruby provides more safe concurrency abstractions than any
56
+ other Ruby library, many of which support the mantra of
57
+ ["Do not communicate by sharing memory; instead, share memory by communicating"](https://blog.golang.org/share-memory-by-communicating).
58
+ Concurrent Ruby is also the only Ruby library which provides a full suite of thread safe and
59
+ immutable variable types and data structures.
46
60
 
47
- It is critical to remember, however, that Ruby is a language of mutable references. *No* concurrency library for Ruby can ever prevent the user from making thread safety mistakes (such as sharing a mutable object between threads and modifying it on both threads) or from creating deadlocks through incorrect use of locks. All the library can do is provide safe abstractions which encourage safe practices. Concurrent Ruby provides more safe concurrency abstractions than any other Ruby library, many of which support the mantra of ["Do not communicate by sharing memory; instead, share memory by communicating"](https://blog.golang.org/share-memory-by-communicating). Concurrent Ruby is also the only Ruby library which provides a full suite of thread safe and immutable variable types and data structures.
61
+ We've also initiated discussion to document [memory model](docs-source/synchronization.md) of Ruby which
62
+ would provide consistent behaviour and guarantees on all three of the main Ruby interpreters
63
+ (MRI/CRuby, JRuby, Rubinius, TruffleRuby).
48
64
 
49
65
  ## Features & Documentation
50
66
 
51
- The primary site for documentation is the automatically generated [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html)
67
+ **The primary site for documentation is the automatically generated
68
+ [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/index.html) which is up to
69
+ date with latest release.** This readme matches the master so may contain new stuff not yet
70
+ released.
71
+
72
+ We also have a [IRC (gitter)](https://gitter.im/ruby-concurrency/concurrent-ruby).
73
+
74
+ ### Versioning
75
+
76
+ * `concurrent-ruby` uses [Semantic Versioning](http://semver.org/)
77
+ * `concurrent-ruby-ext` has always same version as `concurrent-ruby`
78
+ * `concurrent-ruby-edge` will always be 0.y.z therefore following
79
+ [point 4](http://semver.org/#spec-item-4) applies *"Major version zero
80
+ (0.y.z) is for initial development. Anything may change at any time. The
81
+ public API should not be considered stable."* However we additionally use
82
+ following rules:
83
+ * Minor version increment means incompatible changes were made
84
+ * Patch version increment means only compatible changes were made
52
85
 
53
- We also have a [mailing list](http://groups.google.com/group/concurrent-ruby) and [IRC (gitter)](https://gitter.im/ruby-concurrency/concurrent-ruby).
54
86
 
55
87
  #### General-purpose Concurrency Abstractions
56
88
 
57
- * [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to a class. Loosely based on Erlang's [gen_server](http://www.erlang.org/doc/man/gen_server.html).
58
- * [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html): An asynchronous operation that produces a value.
59
- * [Dataflow](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#dataflow-class_method): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
60
- * [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features.
61
- * [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html): Like a Future scheduled for a specific future time.
62
- * [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals.
89
+ * [Async](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Async.html):
90
+ A mixin module that provides simple asynchronous behavior to a class. Loosely based on Erlang's
91
+ [gen_server](http://www.erlang.org/doc/man/gen_server.html).
92
+ * [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ScheduledTask.html):
93
+ Like a Future scheduled for a specific future time.
94
+ * [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/TimerTask.html):
95
+ A Thread that periodically wakes up to perform work at regular intervals.
96
+ * [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html):
97
+ Unified implementation of futures and promises which combines features of previous `Future`,
98
+ `Promise`, `IVar`, `Event`, `dataflow`, `Delay`, and (partially) `TimerTask` into a single
99
+ framework. It extensively uses the new synchronization layer to make all the features
100
+ **non-blocking** and **lock-free**, with the exception of obviously blocking operations like
101
+ `#wait`, `#value`. It also offers better performance.
63
102
 
64
103
  #### Thread-safe Value Objects, Structures, and Collections
65
104
 
66
105
  Collection classes that were originally part of the (deprecated) `thread_safe` gem:
67
106
 
68
- * [Array](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Array.html) A thread-safe subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
69
- * [Hash](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Hash.html) A thread-safe subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
70
- * [Map](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Map.html) A hash-like object that should have much better performance characteristics, especially under high concurrency, than `Concurrent::Hash`.
71
- * [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Tuple.html) A fixed size array with volatile (synchronized, thread safe) getters/setters.
107
+ * [Array](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Array.html) A thread-safe
108
+ subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
109
+ * [Hash](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Hash.html) A thread-safe
110
+ subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
111
+ * [Set](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Set.html) A thread-safe
112
+ subclass of Ruby's standard [Set](http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html).
113
+ * [Map](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Map.html) A hash-like object
114
+ that should have much better performance characteristics, especially under high concurrency,
115
+ than `Concurrent::Hash`.
116
+ * [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Tuple.html) A fixed size
117
+ array with volatile (synchronized, thread safe) getters/setters.
72
118
 
73
119
  Value objects inspired by other languages:
74
120
 
75
- * [Maybe](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Maybe.html) A thread-safe, immutable object representing an optional value, based on
76
- [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
77
- * [Delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html) Lazy evaluation of a block yielding an immutable result. Based on Clojure's [delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html).
121
+ * [Maybe](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Maybe.html) A thread-safe,
122
+ immutable object representing an optional value, based on
123
+ [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
78
124
 
79
125
  Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
80
126
 
81
- * [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ImmutableStruct.html) Immutable struct where values are set at construction and cannot be changed later.
82
- * [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutableStruct.html) Synchronized, mutable struct where values can be safely changed at any time.
83
- * [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/SettableStruct.html) Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
127
+ * [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ImmutableStruct.html)
128
+ Immutable struct where values are set at construction and cannot be changed later.
129
+ * [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/MutableStruct.html)
130
+ Synchronized, mutable struct where values can be safely changed at any time.
131
+ * [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/SettableStruct.html)
132
+ Synchronized, write-once struct where values can be set at most once, either at construction
133
+ or any time thereafter.
84
134
 
85
135
  Thread-safe variables:
86
136
 
87
- * [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A way to manage shared, mutable, *asynchronous*, independent state. Based on Clojure's [Agent](http://clojure.org/agents).
88
- * [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, mutable, *synchronous*, independent state. Based on Clojure's [Atom](http://clojure.org/atoms).
89
- * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html) A boolean value that can be updated atomically.
90
- * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html) A numeric value that can be updated atomically.
91
- * [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html) An object reference that may be updated atomically.
92
- * [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html) A synchronization point at which threads can pair and swap elements within pairs. Based on Java's [Exchanger](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html).
93
- * [MVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) A synchronized single element container. Based on Haskell's [MVar](https://hackage.haskell.org/package/base-4.8.1.0/docs/Control-Concurrent-MVar.html) and Scala's [MVar](http://docs.typelevel.org/api/scalaz/nightly/index.html#scalaz.concurrent.MVar$).
94
- * [ThreadLocalVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html) A variable where the value is different for each thread.
95
- * [TVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) A transactional variable implementing software transactional memory (STM). Based on Clojure's [Ref](http://clojure.org/refs).
137
+ * [Agent](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Agent.html): A way to
138
+ manage shared, mutable, *asynchronous*, independent state. Based on Clojure's
139
+ [Agent](http://clojure.org/agents).
140
+ * [Atom](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Atom.html): A way to manage
141
+ shared, mutable, *synchronous*, independent state. Based on Clojure's
142
+ [Atom](http://clojure.org/atoms).
143
+ * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicBoolean.html)
144
+ A boolean value that can be updated atomically.
145
+ * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicFixnum.html)
146
+ A numeric value that can be updated atomically.
147
+ * [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicReference.html)
148
+ An object reference that may be updated atomically.
149
+ * [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Exchanger.html)
150
+ A synchronization point at which threads can pair and swap elements within pairs. Based on
151
+ Java's [Exchanger](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html).
152
+ * [MVar](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/MVar.html) A synchronized
153
+ single element container. Based on Haskell's
154
+ [MVar](https://hackage.haskell.org/package/base-4.8.1.0/docs/Control-Concurrent-MVar.html) and
155
+ Scala's [MVar](http://docs.typelevel.org/api/scalaz/nightly/index.html#scalaz.concurrent.MVar$).
156
+ * [ThreadLocalVar](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ThreadLocalVar.html)
157
+ A variable where the value is different for each thread.
158
+ * [TVar](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/TVar.html) A transactional
159
+ variable implementing software transactional memory (STM). Based on Clojure's
160
+ [Ref](http://clojure.org/refs).
96
161
 
97
162
  #### Java-inspired ThreadPools and Other Executors
98
163
 
99
- * See the [thread pool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
164
+ * See the [thread pool](http://ruby-concurrency.github.io/concurrent-ruby/master/file.thread_pools.html)
165
+ overview, which also contains a list of other Executors available.
100
166
 
101
167
  #### Thread Synchronization Classes and Algorithms
102
168
 
103
- * [CountDownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html) A synchronization object that allows one thread to wait on multiple other threads.
104
- * [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html) A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
105
- * [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html) Old school kernel-style event.
106
- * [IVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) Similar to a "future" but can be manually assigned once, after which it becomes immutable.
107
- * [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html) A lock that supports multiple readers but only one writer.
108
- * [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html) A read/write lock with reentrant and upgrade features.
109
- * [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html) A counting-based locking mechanism that uses permits.
110
-
169
+ * [CountDownLatch](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/CountDownLatch.html)
170
+ A synchronization object that allows one thread to wait on multiple other threads.
171
+ * [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/CyclicBarrier.html)
172
+ A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
173
+ * [Event](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Event.html) Old school
174
+ kernel-style event.
175
+ * [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ReadWriteLock.html)
176
+ A lock that supports multiple readers but only one writer.
177
+ * [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ReentrantReadWriteLock.html)
178
+ A read/write lock with reentrant and upgrade features.
179
+ * [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Semaphore.html)
180
+ A counting-based locking mechanism that uses permits.
181
+ * [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicMarkableReference.html)
182
+
183
+ #### Deprecated
184
+
185
+ Deprecated features are still available and bugs are being fixed, but new features will not be added.
186
+
187
+ * ~~[Future](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Future.html):
188
+ An asynchronous operation that produces a value.~~ Replaced by
189
+ [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
190
+ * ~~[.dataflow](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent.html#dataflow-class_method):
191
+ Built on Futures, Dataflow allows you to create a task that will be scheduled when all of
192
+ its data dependencies are available.~~ Replaced by
193
+ [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
194
+ * ~~[Promise](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promise.html): Similar
195
+ to Futures, with more features.~~ Replaced by
196
+ [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
197
+ * ~~[Delay](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Delay.html) Lazy evaluation
198
+ of a block yielding an immutable result. Based on Clojure's
199
+ [delay](https://clojuredocs.org/clojure.core/delay).~~ Replaced by
200
+ [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
201
+ * ~~[IVar](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/IVar.html) Similar to a
202
+ "future" but can be manually assigned once, after which it becomes immutable.~~ Replaced by
203
+ [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
204
+
111
205
  ### Edge Features
112
206
 
113
207
  These are available in the `concurrent-ruby-edge` companion gem.
114
208
 
115
209
  These features are under active development and may change frequently. They are expected not to
116
210
  keep backward compatibility (there may also lack tests and documentation). Semantic versions will
117
- be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move to `concurrent-ruby` when final.
118
-
119
- * [Promises Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promises.html):
120
- Unified implementation of futures and promises which combines features of previous `Future`,
121
- `Promise`, `IVar`, `Event`, `dataflow`, `Delay`, and `TimerTask` into a single framework. It extensively uses the
122
- new synchronization layer to make all the features **non-blocking** and **lock-free**, with the exception of obviously blocking
123
- operations like `#wait`, `#value`. It also offers better performance.
124
- * [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html):
125
- Implements the Actor Model, where concurrent actors exchange messages.
126
- * [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/Channel.html):
127
- Communicating Sequential Processes ([CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes)).
128
- Functionally equivalent to Go [channels](https://tour.golang.org/concurrency/2) with additional
129
- inspiration from Clojure [core.async](https://clojure.github.io/core.async/).
130
- * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
131
- * [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
132
- * [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
133
- * [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LockFreeStack.html)
134
-
135
- #### Statuses:
136
-
137
- *Why are these not in core?*
138
-
139
- - **Promises Framework** - They are being finalized to be able to be moved to core. They'll deprecate old
140
- implementation.
141
- - **Actor** - Partial documentation and tests; depends on new future/promise framework; stability is good.
142
- - **Channel** - Brand new implementation; partial documentation and tests; stability is good.
143
- - **LazyRegister** - Missing documentation and tests.
144
- - **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Need real world battle testing.
211
+ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move to
212
+ `concurrent-ruby` when final.
213
+
214
+ * [Actor](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Actor.html): Implements
215
+ the Actor Model, where concurrent actors exchange messages.
216
+ *Status: Partial documentation and tests; depends on new future/promise framework; stability is good.*
217
+ * [Channel](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Channel.html):
218
+ Communicating Sequential Processes ([CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes)).
219
+ Functionally equivalent to Go [channels](https://tour.golang.org/concurrency/2) with additional
220
+ inspiration from Clojure [core.async](https://clojure.github.io/core.async/).
221
+ *Status: Partial documentation and tests.*
222
+ * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/LazyRegister.html)
223
+ * [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Edge/LockFreeLinkedSet.html)
224
+ *Status: will be moved to core soon.*
225
+ * [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/LockFreeStack.html)
226
+ *Status: missing documentation and tests.*
227
+
228
+ ## Supported Ruby versions
229
+
230
+ MRI 2.0 and above, JRuby 9000, TruffleRuby are supported.
231
+ This gem should be fully compatible with any interpreter that is compliant with Ruby 2.0 or newer.
232
+ Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs is supported.
233
+
234
+ The legacy support for Rubinius is kept but it is no longer maintained, if you would like to help
235
+ please respond to [#739](https://github.com/ruby-concurrency/concurrent-ruby/issues/739).
145
236
 
146
237
  ## Usage
147
238
 
@@ -151,13 +242,16 @@ Everything within this gem can be loaded simply by requiring it:
151
242
  require 'concurrent'
152
243
  ```
153
244
 
245
+ *Requiring only specific abstractions from Concurrent Ruby is not yet supported.*
246
+
154
247
  To use the tools in the Edge gem it must be required separately:
155
248
 
156
249
  ```ruby
157
250
  require 'concurrent-edge'
158
251
  ```
159
252
 
160
- If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.
253
+ If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could
254
+ help to reveal the problem.
161
255
 
162
256
  ## Installation
163
257
 
@@ -193,9 +287,9 @@ and run `bundle install` from your shell.
193
287
  ### C Extensions for MRI
194
288
 
195
289
  Potential performance improvements may be achieved under MRI by installing optional C extensions.
196
- To minimize installation errors the C extensions are available in the `concurrent-ruby-ext` extension
197
- gem. `concurrent-ruby` and `concurrent-ruby-ext` are always released together with same version.
198
- Simply install the extension gem too:
290
+ To minimise installation errors the C extensions are available in the `concurrent-ruby-ext`
291
+ extension gem. `concurrent-ruby` and `concurrent-ruby-ext` are always released together with same
292
+ version. Simply install the extension gem too:
199
293
 
200
294
  ```ruby
201
295
  gem install concurrent-ruby-ext
@@ -220,28 +314,32 @@ and load the appropriate C extensions.
220
314
 
221
315
  #### Note For gem developers
222
316
 
223
- No gems should depend on `concurrent-ruby-ext`. Doing so will force C extensions on your users.
224
- The best practice is to depend on `concurrent-ruby` and let users to decide if they want C extensions.
317
+ No gems should depend on `concurrent-ruby-ext`. Doing so will force C extensions on your users. The
318
+ best practice is to depend on `concurrent-ruby` and let users to decide if they want C extensions.
225
319
 
226
320
  ## Maintainers
227
321
 
228
- * [Petr Chalupa](https://github.com/pitr-ch) (lead maintainer)
229
- * [Jerry D'Antonio](https://github.com/jdantonio) (creator)
230
- * [Michele Della Torre](https://github.com/mighe)
231
- * [Chris Seaton](https://github.com/chrisseaton)
232
- * [Paweł Obrok](https://github.com/obrok)
233
- * [Lucas Allan](https://github.com/lucasallan)
322
+ * [Petr Chalupa](https://github.com/pitr-ch) (lead maintainer, point-of-contact)
323
+ * [Jerry D'Antonio](https://github.com/jdantonio) (creator)
324
+ * [Chris Seaton](https://github.com/chrisseaton)
325
+
326
+ ### Special Thanks to
327
+
328
+ * [Brian Durand](https://github.com/bdurand) for the `ref` gem
329
+ * [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
330
+ * [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
234
331
 
235
- ### Special Thanks
332
+ and to the past maintainers
236
333
 
237
- * [Brian Durand](https://github.com/bdurand) for the `ref` gem
238
- * [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
239
- * [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
334
+ * [Michele Della Torre](https://github.com/mighe)
335
+ * [Paweł Obrok](https://github.com/obrok)
336
+ * [Lucas Allan](https://github.com/lucasallan)
240
337
 
241
338
  ## License and Copyright
242
339
 
243
- *Concurrent Ruby* is free software released under the [MIT License](http://www.opensource.org/licenses/MIT).
340
+ *Concurrent Ruby* is free software released under the
341
+ [MIT License](http://www.opensource.org/licenses/MIT).
244
342
 
245
- The *Concurrent Ruby* [logo](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Logo)
246
- was designed by [David Jones](https://twitter.com/zombyboy).
247
- It is Copyright &copy; 2014 [Jerry D'Antonio](https://twitter.com/jerrydantonio). All Rights Reserved.
343
+ The *Concurrent Ruby* [logo](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Logo) was
344
+ designed by [David Jones](https://twitter.com/zombyboy). It is Copyright &copy; 2014
345
+ [Jerry D'Antonio](https://twitter.com/jerrydantonio). All Rights Reserved.