Tell me about design patterns. What is double-checked locking and what is it used for?

Design patterns are proven solutions to common development problems that help create flexible, scalable, and maintainable systems.

Double-checked locking is a pattern used for lazy initialization of resources in a multithreaded environment with minimal synchronization costs. The idea is to first check if the resource is initialized without locking, and only if it is not, acquire the lock and check again before initializing.

This avoids expensive locking on every access to the resource after it has been initialized.

Example in Go (simplified):

var instance *MyType
var mu sync.Mutex

func GetInstance() *MyType {
    if instance == nil {           // first check without lock
        mu.Lock()
        defer mu.Unlock()
        if instance == nil {       // second check with lock
            instance = &MyType{}
        }
    }
    return instance
}

It is important to note that in some languages and platforms, double-checked locking can be unsafe without additional memory guarantees (e.g., volatile in Java). In Go, it is generally safe when used correctly with synchronization.