memory sharing

messaging

Reorder

sequential consistency

happens-before

as-if-serial

Synchronization, heavyweight lock

principle

lock object

Implementation Mechanism

Lock optimization

characteristic

Implementation Mechanism

memory semantics

operating system semantics

memory model

Singleton pattern

DCL

solution

AbstractQueuedSynchronizer, synchronizer, implements the core basic components of JUC

Solved a large number of detailed issues involved in implementing synchronizers in subclasses, such as obtaining synchronization status and FIFO synchronization queue.

Using the template method pattern, AQS implements a large number of common methods, and subclasses implement their abstract methods through inheritance to manage synchronization status.

CLH sync queue

Synchronous state acquisition and release

Thread blocking and waking up

Compare And Swap, the core and most basic theory of the entire JUC system

Memory value V, old expected value A, and value to be updated B. If and only if the value of memory value V is equal to the old expected value A, the value of memory value V will be modified to B, otherwise nothing will be done.

There are four parameters in native

defect

Reentrant lock is a recursive non-blocking synchronization mechanism

A more powerful and flexible locking mechanism than synchronized, which can reduce the probability of deadlock.

Divided into fair lock and unfair lock

The bottom layer is implemented using AQS and inherits AQS through internal Sync.

Read-write lock, two locks: shared lock: read lock, exclusive lock: write lock

Supports fairness, unfairness, reentrancy and lock degradation

Lock downgrade: According to the order of acquiring write lock, acquiring read lock and releasing write lock, write lock can be downgraded to read lock.

Lock provides Condition, which is more detailed and flexible for thread waiting and waking up operations.

A Condition queue is maintained internally. When the current thread calls the await() method, a node (Node) will be constructed from the current thread, and the node will be added to the end of the queue.

It allows a group of threads to wait for each other until a common barrier point is reached

In layman's terms: let a group of threads be blocked when they reach a barrier. The barrier will not open until the last thread reaches the barrier, and all threads intercepted by the barrier will continue to work.

The bottom layer is implemented using ReentrantLock Condition

Application scenarios

It allows one or more threads to wait until a set of operations being performed in other threads is completed.

Initializes CountDownLatch with the given count. Because the countDown() method is called, the await method blocks until the current count reaches zero. Afterwards, all waiting threads are released and all subsequent calls to await return immediately. This behavior only occurs once - the count cannot be reset. If you need to reset the count, consider using a CyclicBarrier.

Difference from CyclicBarrier

Internally implemented using shared locks

signal

Conceptually, a semaphore maintains a permission set. If necessary, each acquire() blocks until the permission is available, and then acquires the permission. Each release() adds a permission, potentially releasing a blocking getter. However, instead of using the actual license object, Semaphore just counts the number of available licenses and takes action accordingly

The semaphore Semaphore is a non-negative integer (>=1). When a thread wants to access a shared resource, it must first obtain the Semaphore. When Semaphore > 0, obtain the resource and set Semaphore - 1. If the Semaphore value = 0, it means that all shared resources have been occupied by other threads, and the thread must wait for other threads to release the resources. When the thread releases the resource, the Semaphore is 1

Application scenarios

Internally implemented using shared locks

A synchronization point for threads that can pair and swap elements in a pair

Allows data to be exchanged between concurrent tasks. Specifically, the Exchanger class allows synchronization points to be defined between two threads. When both threads reach the synchronization point, they exchange data structures, so the first thread's data structure goes into the second thread, and the second thread's data structure goes into the first thread

A solution to the problem of member variables in a multi-threaded environment, but has nothing to do with thread synchronization. The idea is to create a separate copy of the variable for each thread, so that each thread can independently change its own copy of the variable without affecting the corresponding copies of other threads.

ThreadLocal is not used to solve the problem of shared variables, nor does it exist to coordinate thread synchronization, but is a mechanism introduced to facilitate each thread to handle its own state.

four methods

ThreadLocalMap

be careful

memory leak problem

A framework for executing tasks in parallel is a framework that divides large tasks into several small tasks, and finally aggregates the results of each small task to obtain the results of the large task.

main idea

job theft

core class

CAS Synchronized to ensure the safety of concurrent updates, the bottom layer uses an array linked list/red-black tree storage structure

Important inner classes

Important operations

The difference between 1.8 and 1.7

An unbounded thread-safe queue based on link nodes, using the FIFO principle to sort elements, and internally implemented using the CAS algorithm

immutability

Invariance and variability of head

Invariance and variability of tail

Subtlety: CAS is used to complete data operations while allowing inconsistency in the queue, and weak consistency is fully demonstrated.

The third key-value data structure: SkipList (skip list)

SkipList

Internally implemented using ConcurrentSkipListMap

Used to update basic types atomically

AtomicBoolean

AtomicInteger

AtomicLong

Update an element in an array atomically

AtomicIntegerArray

AtomicLongArray

AtomicReferenceArray

If you want to update multiple variables atomically, you need to use the class provided by this atomic update reference type.

AtomicReference

AtomicReferenceFieldUpdater

AtomicMarkableReference

If we only need a certain field in a certain class, then we need to use atomic update of the field class

AtomicIntegerFieldUpdater

AtomicLongFieldUpdater

AtomicStampedReference

A FIFO bounded blocking queue implemented as an array

ArrayBlockingQueue is bounded and fixed. The size is confirmed during the constructor. Changes are not supported after confirmation.

"Fairness" is not guaranteed in a multi-threaded environment

accomplish

Link-based, unbounded FIFO blocking queue

Unbounded blocking queue with priority support

By default, elements are sorted in ascending order in natural order. You can sort elements by specifying a Comparator.

binary heap

accomplish

Unbounded blocking queue that supports delayed acquisition of elements

application

accomplish

Delayed interface

A blocking queue with no capacity

application

Difficult to understand, has difficulty with Exchanger

Unbounded blocking queue composed of linked list

Equivalent to a superset of ConcurrentLinkedQueue, SynchronousQueue (in fair mode), unbounded LinkedBlockingQueues, etc.

preemptive mode

A two-way blocking queue composed of a linked list

Capacity is optional. You can set the capacity during initialization to prevent excessive expansion. If not set, the default capacity is Integer.MAX_VALUE.

use

Reduce resource consumption

Improve response speed

Improve thread manageability

Executors

ThreadPoolExecutor

ScheduledThreadPoolExecutor

Asynchronous calculation

Future

FutureTask