TCP sliding window, singleton mode (lazy and hungry) double checked locking / double checked locking (DCL)

TCP Sliding window of

Zhihu Video Explanation ： Network transmission principle ： What is? TCP The sliding window

Sliding window of network programming (TCP flow control )

The singleton pattern （ Lazy and hungry ）

In traditional textbooks, there are two kinds of single case mode , It's a hungry man style , A lazy style . The corresponding code is as follows ：
Explain in detail the dual hungry man mode and the lazy man mode ： Lazy mode in singleton mode , Starving model , Double check lock / Double check lock

Hungry Chinese style

public class Singleton {
      
    private static Singleton instance = new Singleton();   //  It will be instantiated when the class is loaded  
    private Singleton (){
    }  
    public static Singleton getInstance() {
      
    return instance;  
    }  
}

Hungry Chinese instantiates when the class is loaded , Call directly when using getInstance() Method . This mode is thread safe , In multi-threaded concurrency mode, objects will not be instantiated repeatedly .
advantage ： Efficient shortcoming ： Premature object instantiation , Waste memory resources

The sluggard model

public class Singleton {
    
    private static Singleton singleton;
    private Singleton() {
    
    }

 public static Singleton getInstance() {
    
        if (singleton == null) {
    
            singleton = new Singleton();
        }
        return singleton;
    }
}

This mode does not instantiate objects at load time , It's calling getInstance() Method to instantiate the object , Lazy is used to avoid premature instantiation , Reduce the waste of memory resources .
advantage ： The first call initializes , Avoid memory waste . shortcoming ： Only suitable for single thread , Thread unsafe

Reference resources ： Use singleton mode to talk about thread safety
Double check lock / Double check lock （DCL, namely double-checked locking）
Reference resources ： Double check lock / Double check lock （DCL, namely double-checked locking） Detailed analysis

public class Singleton {
    
    private volatile static Singleton instance;

    private Singleton() {
    
    }

    public static Singleton getInstance() {
    
        if (instance == null) {
    
            synchronized (Singleton.class) {
    
                if (instance == null) {
    
                    instance = new Singleton();//erro
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
    
        Singleton.getInstance();
    }
}

Why double check

    public static Singleton getInstance() {
    
        if (instance == null) {
    // Threads 1,2 Arrive at the same time , All pass （instance == null） Judge .
                                //  Threads 1 Enter the following synchronization block , Threads 2 Blocked 
            synchronized (Singleton.class) {
    
                if (instance == null) {
    // Threads 1 Perform discovery instance by null, After initializing an instance , Release the lock .
                    //  Threads 2 Go into sync block , this instance Has been initialized . Unable to get if Conditions , Avoid repeated initialization .
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

Double check is performed because , If multiple threads pass the first detection , At this time because synchronized, One of the threads will first pass the second detection and instantiate the object , The remaining threads will not instantiate the object repeatedly . such , In addition to locking during initialization , Subsequent calls return directly , It solves the redundant performance consumption .

Why use volatile Double lock

                if (instance == null) {
    
                    instance = new Singleton();//erro
                }

If not used volatile keyword , The hidden trouble comes from the comments in the above code erro A line , This line of code has roughly the following three steps ：

• Open up the space required for objects in the heap , Allocation address
• Initialize according to the initialization order of class loading
• Return the memory address to the reference variable in the stack

because Java The memory model allows “ Unordered write ”, Some compilers for performance reasons , It is possible to 2 and 3 Reorder , The order becomes

• Open up the space required for objects in the heap , Allocation address
• Return the memory address to the reference variable in the stack （ At this time, the variable is no longer null, But variables are not initialized ）
• Initialize according to the initialization order of class loading
  
  Reference resources ： The double check lock implements the singleton mode