Index
A
- ABA problem
- about / The ABA problem
- thread locals / Thread locals
- free nodes, pooling / Pooling the free nodes
- atomic stamped reference / The atomic stamped reference
- active objects
- about / Active objects
- adapting / Hiding and adapting
- hiding / Hiding and adapting
- proxy, using / Using a proxy
- actor
- about / What is an actor?
- crashing / Let it crash
- location transparency, maintaining / Location transparency
- features / Actors are featherlight
- communicating, ask pattern used / Actor communication – the ask pattern
- communicating, with each other / Actors talking with each another
- communicating, tell pattern used / Actor communication – the tell pattern
- communicating, pipeTo pattern used / The pipeTo pattern
- actor paradigm / The actor paradigm
- apply method
- about / The apply method
- by-name parameters, using / by-name parameters
- ask pattern
- used, for communicating between actors / Actor communication – the ask pattern
- asynchronous model / Asynchronous versus synchronous executions
- atomic reference / A lock-free stack
B
- backing object / Unmodifiable wrappers
- become pattern
- used, for changing actors behavior / The become pattern
- state, making immutable / Making the state immutable
- big lock approach
- about / The big lock approach
- resizing strategy / The resizing strategy
- botched optimization attempt
- reference / Correct memory visibility and happens-before
- bounded buffer
- about / A bounded buffer
- client polls / Strategy pattern – client polls
- polling / Strategy – taking over the polling and sleeping
- sleeping / Strategy – taking over the polling and sleeping
- condition variables, using / Strategy – using condition variables
C
- CAS (Compare And Set) / Comparing and swapping
- combinators / Functional composition
- composability / Software transactional memory
- concurrency
- about / Concurrency in a breeze
- issue / The push for concurrency
- MapReduce pattern / The MapReduce pattern
- fault tolerance / Fault tolerance
- concurrent hashing
- about / Concurrent hashing
- add(v) method, using / The add(v) method
- concurrent programming
- contains(v) method
- using / The contains(v) method
- countdown latch
- about / Countdown latch
- implementing / Implementing the countdown latch
- cyclic barrier / A cyclic barrier
D
- decorator pattern
- reference / Unmodifiable wrappers
- double-checked locking
- about / Double-checked locking
- safe publication / Safe publication
- demand holder pattern, initializing / Initializing a demand holder pattern
E
- enum
- reference / Initializing a demand holder pattern
- event-driven architecture (EDA) / Event-driven architecture
- event-driven programming / Event-driven architecture
- explicit locking
- about / Explicit locking
- hand-over-hand pattern / The hand-over-hand pattern
- observations, checking / Observations – is it correct?
F
- fair lock
- implementing / A fair lock
- FIFO (first in, first out) queue / The shared memory and shared state model, A lock-free FIFO queue
- final fields
- about / Visibility and final fields
- visibility / Visibility and final fields
- fork-join pool
- about / The fork-join pool
- egrep / Egrep – simple version
- recursive task, using / Why use a recursive task?
- task parallelism / Task parallelism
- used, for quicksort implementation / Quicksort – using fork-join
- futures
- about / Futures
- apply method / The apply method
- thread mapping / Future – thread mapping
- as asynchronous / Futures are asynchronous
- context, blocking / Blocking is bad
- functional composition / Functional composition
- future task / A future task
G
- Gang Of Four (GOF) / Race conditions
- GNU parallel
- reference / Divide and conquer
H
- heisenbugs / Race conditions and heisenbugs
- horizontal scaling
- about / The push for concurrency
I
- immutable objects
- about / Immutability
- unmodified wrappers / Unmodifiable wrappers
- reference / Unmodifiable wrappers
- persistent data structures / Persistent data structures
- recursion feature / Recursion and immutability
J
- Java Language Specification (JLS) / Initializing a demand holder pattern
L
- last in, first out (LIFO) stack / A lock-free stack
- Load Barrier / Race conditions
- lock-free FIFO queue
- about / A lock-free FIFO queue
- working / How the flow works
- lock-free queue
- about / A lock-free queue
- using / Going lock-free
- enque(v) method, using / The enque(v) method
- deq() method, using / The deq() method
- concurrent execution, of enque and deque methods / Concurrent execution of the enque and deque methods
- lock-free stack
- about / A lock-free stack
- atomic references / Atomic references
- implementing / The stack implementation
- lock-striping design pattern / The map-reduce theme
- lock striping design pattern / The lock striping design pattern
M
- map-reduce theme / The map-reduce theme
- message brokers / Message brokers
- message driven concurrency
- about / Message driven concurrency
- actor / What is an actor?
- state encapsulation / State encapsulation
- parallelism / Where is the parallelism?
- unhandled messages / Unhandled messages
- become pattern / The become pattern
- let-it-crash, working / Let it crash - and recover
- message passing model
- about / The message passing model
- coordination / Coordination and communication
- communication / Coordination and communication
- flow control / Flow control
- divide and conquer / Divide and conquer
- concept of state / The concept of state
- monitor pattern / The monitor pattern
N
- Netty framework
- reference / Java's nonblocking I/O
O
- of pattern / Of patterns and paradigms
- operating system (OS) / The message passing model
P
- paradigms / Of patterns and paradigms
- parallel collections / Parallel collections
- pipeTo pattern
- used, for communication between actors / The pipeTo pattern
- poison pill
- reference / Coordination and communication
- producer/consumer pattern
- about / The producer/consumer pattern
- wake-ups / Spurious and lost wake-ups
Q
- quicksort implementation
- fork-join API, using / Quicksort – using fork-join
- ForkJoinQuicksortTask class / The ForkJoinQuicksortTask class
- copy-on-write theme / The copy-on-write theme
- in-place sorting / In-place sorting
R
- race conditions
- about / Race conditions
- monitor pattern / The monitor pattern
- thread safety / Thread safety, correctness, and invariants
- correctness / Thread safety, correctness, and invariants
- invariants / Thread safety, correctness, and invariants
- double-checked locking / Double-checked locking
- explicit locking / Explicit locking
- producer/consumer pattern / The producer/consumer pattern
- CAS (Compare And Set) instruction / Comparing and swapping
- Reactive Extensions (Rx) / Reactive programming
- reactive programming / Reactive programming
- ReactiveX
- reference / Reactive programming
- Readers–Writer (RW) lock
- about / Reader or writer locks
- using / A reader-friendly RW lock
- reentrant lock / Our own reentrant lock
- Resilient Distributed Dataset (RDD) / Parallel collections
- resizing
- need for / The need to resize
S
- semaphores
- counting / Counting semaphores
- sequential consistency tool / Sequential consistency
- Shared-Exclusive lock / Reader or writer locks
- shared memory and shared state model
- about / The shared memory and shared state model
- threads, interleaving / Threads interleaving – the need for synchronization
- heisenbugs / Race conditions and heisenbugs
- race conditions / Race conditions and heisenbugs
- correct memory visibility / Correct memory visibility and happens-before
- happens-before relationship / Correct memory visibility and happens-before
- new state / Sharing, blocking, and fairness
- runnable state / Sharing, blocking, and fairness
- running state / Sharing, blocking, and fairness
- blocked state / Sharing, blocking, and fairness
- waiting address / Sharing, blocking, and fairness
- Timed Wait state / Sharing, blocking, and fairness
- terminated state / Sharing, blocking, and fairness
- asynchronous, versus synchronous executions / Asynchronous versus synchronous executions
- Java's nonblocking I/O / Java's nonblocking I/O
- software transactional memory / Software transactional memory
- store barrier / Race conditions
T
- Tail recursion Optimization (TCO) / Recursion and immutability
- tell operator / Message driven concurrency
- tell pattern
- used, for communication between actors / Actor communication – the tell pattern
- thread / The shared memory and shared state model, A thread and its context
- thread context / A thread and its context
- thread pools
- about / Thread pools
- command design pattern / The command design pattern
- word-counting program / Counting words
- version / Another version
- blocking queue / The blocking queue
- interruption semantics / Thread interruption semantics
- thread scheduler
- runnable state / Sharing, blocking, and fairness
- time sharing / Time sharing
V
- vertical scaling
- reference / The push for concurrency
W
- work stealing / Work stealing