High Concurrent Programming in Actual java Chapter 5: Parallel Patterns and Algorithms

Keywords: Java less network

Singleton mode


  1. 1
  2. 2
  3. Listing 3

    Definition: A class produces only one instance in the system
    Advantages: For frequently used objects, new time can be omitted, which is an objective system performance improvement for heavyweight objects.

        Lower memory usage, less GC times and shorter GC pause time
//Singleton objects must be created when the hungry Chinese class is first used
public class Singleton {
    public static int STATUS=1;
    private Singleton(){
        System.out.println("Singleton is create");
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return instance;

//In the lazy concurrent environment, the performance of locks is poor when the competition is fierce.
public class LazySingleton {
    private LazySingleton() {
        System.out.println("LazySingleton is create"); 
    private static LazySingleton instance = null;
    public static synchronized LazySingleton getInstance() {
        if (instance == null)
            instance = new LazySingleton();
        return instance;

//Static internal classes // sets the two advantages mentioned above
public class StaticSingleton {
    public static int STATUS;
    private StaticSingleton(){
        System.out.println("StaticSingleton is create");
    private static class SingletonHolder {
        private static StaticSingleton instance = new StaticSingleton();
    public static StaticSingleton getInstance() {
        return SingletonHolder.instance;
Be careful:
In addition, there is a double checking mode to create singletons, which is ugly and complex, even in the low version can not guarantee correctness, and is not recommended for use.

Invariant pattern

Definition: Once an object is created, its internal state never changes, so it is always thread-safe
 Use scenarios: After object creation, internal state and data no longer change
         Objects need to be shared and frequently accessed by multiple threads
public final class PCData {        //The parent class remains unchanged, and the child class must remain unchanged, but this cannot be guaranteed, so use final.
    private  final int intData;    //Be assigned only once
    public PCData(int d){
    public PCData(String d){
    public int getData(){
        return intData;
    public String toString(){
        return "data:"+intData;
Be careful:
String classes are also invariant, guaranteeing performance under multithreading

Producer Consumption Model

Producer Consumption Model: Lockless Realization

Future mode

parallel pipeline

Parallel search

Parallel sorting

Parallel algorithm: matrix multiplication

Network NIO

Asynchronous AIO

Posted by shane0714 on Thu, 03 Oct 2019 01:45:13 -0700