Concurrency

Glossary

• Synchronous:  
• When you start a program, you must wait until it finishes before moving on to the next step.
• Asynchronous:
• When you start a program, it returns immediately and runs the program in the background, and you can move on to the next step.
• Concurrency:
• 
  
  
  
  
• Concurrency is the ability of different parts or units of a program, algorithm, or problem to be executed out-of-order or in the partial order, without affecting the final outcome
• Parallelism:
• 
  
  
• Parallel computing is a type of computation in which many calculations or processes are carried out simultaneously.
• Blocking:
• A process that is blocked is one that is waiting for some event, such as a resource becoming available or the completion of an I/O operation
• Non-blocking:
• An algorithm is called non-blocking if the failure or suspension of any thread cannot cause the failure or suspension of another thread

Concurrency level

• Blocking:
• A thread is blocked and it cannot execute until other threads release resources.
• Starvation-Free:
• Resource allocation is fair to all threads.
• Obstruction-Free:
• A method is obstruction-free if, from any point after which it executes in isolation, it finishes in a finite number of steps (method call executes in isolation if no other threads take steps).
• Lock-Free:
• A method is lock-free if it guarantees that infinitely often some method call finishes in a finite number of steps.
• Wait-Free:
• A method is wait-free if it guarantees that every call finishes its execution in a finite number of steps.

Concurrency concept

• Atomicity:
• Atomicity means that an operation is non-interruptible. Even when multiple threads are executed together, the operation will not be disturbed by other threads once it is started. That is, an atomic operation is a small operation.
• Visibility:
• Visibility is when a thread modifies the value of a shared variable, and whether another thread can immediately know the change.
• Ordering:
• When it comes to ordering, it inevitably has a disorderly order, which is caused by the JVM's command rearrangement optimization.
• If we want to keep order completely, we need to add a synchronous lock (synchronized) to the object, which is actually a single thread execution.

Concurrency programming optimization

• Use thread pools to reduce thread creation costs.
• Use concurrent package tools.
• Use immutable variables or do not share resources.
• Suggestions to improve lock performance:
• Reduce lock-holding time.
• Reduce lock granularity.
• Read-write separation lock to replace the exclusive lock.
• Lock separation.
• Lock coarsening (reduce lock requests).

reference:

https://en.wikipedia.org/wiki/Concurrency_(computer_science)

https://en.wikipedia.org/wiki/Parallel_computing

https://en.wikipedia.org/wiki/Blocking_(computing)

https://en.wikipedia.org/wiki/Non-blocking_algorithm

https://stackoverflow.com/questions/4432527/what-is-the-difference-between-lock-free-and-obstruction-free

https://topic.alibabacloud.com/a/the-atomicity-ordering-visibility-and-happen-before-principles-of-java-concurrency_1_12_30730185.html