Singleton Design Pattern

public final class ConfigLoader {

    private final Map<String, String> settings;

    private ConfigLoader() {
        // Expensive: parses config.yml off disk. We want this to happen once.
        this.settings = YamlParser.parse(Path.of("config.yml"));
    }

    // The initialization-on-demand holder idiom. Holder isn't loaded until
    // getInstance() is first called, and the JVM guarantees class
    // initialisation is thread-safe — so this is lazy AND safe with no
    // synchronized block and no volatile field.
    private static final class Holder {
        static final ConfigLoader INSTANCE = new ConfigLoader();
    }

    public static ConfigLoader getInstance() {
        return Holder.INSTANCE;
    }

    public String get(String key) {
        return settings.get(key);
    }
}

// If you don't need laziness, `public enum ConfigLoader { INSTANCE; ... }` is
// shorter and is the only form the JVM defends against reflection and
// deserialisation attacks (Effective Java, item 3).

# config_loader.py
#
# Python already has a singleton mechanism: the module. `import config_loader`
# runs the module body once and caches it in sys.modules, so every importer in
# the process gets the same object. A hand-rolled __new__ override or a
# metaclass is almost always the wrong answer here.

from functools import cache
from pathlib import Path

import yaml


class ConfigLoader:
    def __init__(self) -> None:
        # Expensive: parses config.yml off disk.
        self._settings: dict[str, str] = yaml.safe_load(
            Path("config.yml").read_text()
        )

    def get(self, key: str) -> str | None:
        return self._settings.get(key)


@cache  # memoises on the (empty) argument list -> built once, returned forever
def get_instance() -> ConfigLoader:
    return ConfigLoader()


# Callers:  from config_loader import get_instance
#           get_instance().get("db.host")
#
# functools.cache is thread-safe for this use: two threads may both run the
# body, but only one result is kept, so callers still agree on one object.
# Need a hard guarantee that the body runs once? Wrap it in a threading.Lock.

#include <string>
#include <unordered_map>

class ConfigLoader {
public:
    // The "Meyers singleton". Since C++11 the standard guarantees a
    // function-local static is initialised exactly once, even if several
    // threads reach this line simultaneously — the compiler emits the guard.
    static ConfigLoader& instance() {
        static ConfigLoader loader;  // built on first call, destroyed at exit
        return loader;
    }

    // A copyable singleton is not a singleton. Delete both, or a stray
    // `auto copy = ConfigLoader::instance();` silently gives you a second one.
    ConfigLoader(const ConfigLoader&)            = delete;
    ConfigLoader& operator=(const ConfigLoader&) = delete;

    std::string get(const std::string& key) const {
        const auto it = settings_.find(key);
        return it == settings_.end() ? std::string{} : it->second;
    }

private:
    ConfigLoader() : settings_(parse_yaml("config.yml")) {}  // expensive, once
    ~ConfigLoader() = default;

    std::unordered_map<std::string, std::string> settings_;
};

// Usage:  ConfigLoader::instance().get("db.host");
// Note it returns a reference, not a pointer — there is no null case to handle
// and no question about who owns it.

public sealed class ConfigLoader
{
    // Lazy<T> defaults to LazyThreadSafetyMode.ExecutionAndPublication, so this
    // one line replaces the entire double-checked-locking ritual: the factory
    // runs at most once and every other thread blocks until it finishes.
    private static readonly Lazy<ConfigLoader> _instance =
        new(() => new ConfigLoader());

    public static ConfigLoader Instance => _instance.Value;

    private readonly IReadOnlyDictionary<string, string> _settings;

    private ConfigLoader()
    {
        // Expensive: parses config.yml off disk.
        _settings = YamlParser.Parse(File.ReadAllText("config.yml"));
    }

    public string? Get(string key) =>
        _settings.TryGetValue(key, out var value) ? value : null;
}

// In an ASP.NET Core app, prefer letting the container own the lifetime:
//
//     services.AddSingleton<IConfigLoader, ConfigLoader>();
//
// You get the same single instance, but it arrives by constructor injection —
// so it is still swappable in tests, which the static property above is not.

// config-loader.js
//
// An ES module body is evaluated exactly once per specifier, no matter how many
// files import it. The module system IS the singleton — writing a class with a
// private constructor on top of that is ceremony for its own sake.

import { readFileSync } from 'node:fs'
import { parse } from 'yaml'

// Expensive: parses config.yml off disk. Runs on first import, never again.
const settings = parse(readFileSync('config.yml', 'utf8'))

export function get(key) {
  return settings[key]
}

// Freezing stops a caller mutating shared state that forty other modules read.
export default Object.freeze({ get })

// Callers:  import config from './config-loader.js'
//           config.get('db.host')
//
// Caveat: "once per specifier" is per module registry. A CommonJS build and an
// ESM build of the same file, or two copies in node_modules, are two instances.

package config

import (
	"os"
	"sync"

	"gopkg.in/yaml.v3"
)

type Loader struct {
	settings map[string]string
}

var (
	instance *Loader
	once     sync.Once
)

// Instance returns the one Loader. sync.Once guarantees the function argument
// runs exactly once for the life of the process, and that every other goroutine
// blocks until that first call has returned — which is the whole pattern.
func Instance() *Loader {
	once.Do(func() {
		raw, err := os.ReadFile("config.yml") // expensive, happens once
		if err != nil {
			panic(err)
		}
		s := map[string]string{}
		if err := yaml.Unmarshal(raw, &s); err != nil {
			panic(err)
		}
		instance = &Loader{settings: s}
	})
	return instance
}

func (l *Loader) Get(key string) string { return l.settings[key] }

// Go has no private constructors, so nothing stops `&Loader{}`. The convention
// is to keep the struct unexported (`loader`) and export only Instance().
// Panicking in a package-level initialiser is also frowned on — in real code,
// prefer `func New() (*Loader, error)` wired once in main().

export class ConfigLoader {
  private static instance: ConfigLoader | null = null

  private readonly settings: Readonly<Record<string, string>>

  // The private constructor is what actually enforces the pattern: outside this
  // file, `new ConfigLoader()` is a compile error rather than a code-review note.
  private constructor() {
    // Expensive: parses config.yml off disk.
    this.settings = Object.freeze(parseYaml(readFileSync('config.yml', 'utf8')))
  }

  static getInstance(): ConfigLoader {
    // No lock needed: JavaScript runs this on a single thread, so the check and
    // the assignment cannot be interleaved. Every other language on these tabs
    // needs a guard here; TypeScript genuinely does not.
    ConfigLoader.instance ??= new ConfigLoader()
    return ConfigLoader.instance
  }

  get(key: string): string | undefined {
    return this.settings[key]
  }
}

// Worth knowing: a plain module-level `export const config = new ConfigLoader()`
// gets you the same guarantee with less code. Reach for the class form when you
// need the creation to be lazy, or the type to be exported without the instance.