class Singleton {
  private static instance: Singleton | null = null;
  private value: number;
 
  // private constructor で外部からの new を禁止
  private constructor(value: number) {
    this.value = value;
    console.log("Singleton: コンストラクタ実行（1度だけ）");
  }
 
  static getInstance(): Singleton {
    if (!Singleton.instance) {
      Singleton.instance = new Singleton(42);
    }
    return Singleton.instance;
  }
 
  getValue(): number {
    return this.value;
  }
 
  setValue(value: number): void {
    this.value = value;
  }
}
 
// 使用例
const a = Singleton.getInstance();
const b = Singleton.getInstance();
 
console.log(a === b);         // true — 同一インスタンス
console.log(a.getValue());    // 42
 
a.setValue(100);
console.log(b.getValue());    // 100 — 同じインスタンスなので反映される

// private constructor がない場合の危険
const s1 = new Singleton(1);  // 直接生成 → 制御不能
const s2 = new Singleton(2);  // 2つ目が生成されてしまう

// config.ts — ES Module 自体が Singleton として振る舞う
class AppConfig {
  readonly dbHost: string;
  readonly dbPort: number;
  readonly logLevel: string;
  readonly maxRetries: number;
 
  constructor() {
    // 環境変数からの読み込み（1度だけ実行される）
    this.dbHost = process.env.DB_HOST ?? "localhost";
    this.dbPort = Number(process.env.DB_PORT ?? 5432);
    this.logLevel = process.env.LOG_LEVEL ?? "info";
    this.maxRetries = Number(process.env.MAX_RETRIES ?? 3);
 
    console.log("AppConfig: 初期化完了");
  }
 
  get connectionString(): string {
    return `postgresql://${this.dbHost}:${this.dbPort}/mydb`;
  }
}
 
// モジュールレベルで1度だけインスタンス化
// import した全てのモジュールが同じインスタンスを受け取る
export const appConfig = new AppConfig();
 
// --- 利用側 ---
// import { appConfig } from './config';
// console.log(appConfig.connectionString);

public class Singleton {
    // volatile: メモリの可視性を保証（CPUキャッシュの問題を防ぐ）
    private static volatile Singleton instance;
 
    private Singleton() {
        // 重い初期化処理（例: DB接続、設定ファイル読み込み）
        System.out.println("Singleton: 初期化実行");
    }
 
    public static Singleton getInstance() {
        if (instance == null) {                  // 1st check (ロックなし — 高速パス)
            synchronized (Singleton.class) {     // ロック取得
                if (instance == null) {          // 2nd check (ロック内で再確認)
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Singleton {
    private Singleton() {
        System.out.println("Singleton: 初期化実行");
    }
 
    // 内部クラスは、最初にアクセスされるまでロードされない
    private static class Holder {
        // static final により JVM が初期化の排他制御を保証
        private static final Singleton INSTANCE = new Singleton();
    }
 
    public static Singleton getInstance() {
        return Holder.INSTANCE;  // 初回呼出時に Holder クラスがロードされる
    }
}

public enum Singleton {
    INSTANCE;
 
    private int value;
 
    public int getValue() {
        return value;
    }
 
    public void setValue(int value) {
        this.value = value;
    }
 
    public void doSomething() {
        System.out.println("Singleton operation with value: " + value);
    }
}
 
// 使用
Singleton.INSTANCE.setValue(42);
Singleton.INSTANCE.doSomething();

import threading
 
class SingletonMeta(type):
    """スレッドセーフなSingletonメタクラス"""
    _instances: dict = {}
    _lock: threading.Lock = threading.Lock()
 
    def __call__(cls, *args, **kwargs):
        # Double-Checked Locking パターン
        if cls not in cls._instances:
            with cls._lock:
                if cls not in cls._instances:
                    instance = super().__call__(*args, **kwargs)
                    cls._instances[cls] = instance
        return cls._instances[cls]
 
class Database(metaclass=SingletonMeta):
    def __init__(self):
        self.connection = "connected"
        print(f"Database: 初期化実行 (id={id(self)})")
 
    def query(self, sql: str) -> str:
        return f"Result of: {sql}"
 
# 使用
db1 = Database()  # "Database: 初期化実行 (id=...)"
db2 = Database()  # 出力なし（既存インスタンスを返す）
 
print(db1 is db2)            # True
print(db1.query("SELECT 1")) # "Result of: SELECT 1"

from functools import wraps
 
def singleton(cls):
    """Singletonデコレータ"""
    instances = {}
 
    @wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
 
    return get_instance
 
@singleton
class Logger:
    def __init__(self):
        self.logs: list[str] = []
        print("Logger: 初期化実行")
 
    def log(self, message: str):
        self.logs.append(message)
        print(f"[LOG] {message}")
 
# 使用
logger1 = Logger()  # "Logger: 初期化実行"
logger2 = Logger()  # 出力なし
 
logger1.log("Start")
print(logger2.logs)  # ["Start"] — 同じインスタンス

package main
 
import (
    "fmt"
    "sync"
)
 
type singleton struct {
    value int
}
 
var (
    instance *singleton
    once     sync.Once
)
 
func GetInstance() *singleton {
    once.Do(func() {
        fmt.Println("Singleton: 初期化実行")
        instance = &singleton{value: 42}
    })
    return instance
}
 
func main() {
    s1 := GetInstance() // "Singleton: 初期化実行"
    s2 := GetInstance() // 出力なし
 
    fmt.Println(s1 == s2)    // true
    fmt.Println(s1.value)    // 42
}

// sync.Once の内部（簡略版）
type Once struct {
    done uint32     // atomic でチェック（高速パス）
    m    Mutex      // 初回のみ使用
}
 
func (o *Once) Do(f func()) {
    if atomic.LoadUint32(&o.done) == 0 {  // 高速パス
        o.doSlow(f)
    }
}
 
func (o *Once) doSlow(f func()) {
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {  // DCL
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

object AppConfig {
    val dbHost: String = System.getenv("DB_HOST") ?: "localhost"
    val dbPort: Int = System.getenv("DB_PORT")?.toInt() ?: 5432
 
    fun connectionString(): String =
        "postgresql://$dbHost:$dbPort/mydb"
 
    init {
        println("AppConfig: 初期化実行")
    }
}
 
// 使用
fun main() {
    println(AppConfig.connectionString())
    // AppConfig.connectionString() == AppConfig.connectionString() は常に同じ結果
}

// InversifyJS の例
import { Container, injectable, inject } from "inversify";
 
// インタフェース
interface Logger {
  log(message: string): void;
}
 
interface Database {
  query(sql: string): Promise<any>;
}
 
const TYPES = {
  Logger: Symbol.for("Logger"),
  Database: Symbol.for("Database"),
};
 
// 実装クラス（Singleton であることを知らない）
@injectable()
class ConsoleLogger implements Logger {
  constructor() {
    console.log("ConsoleLogger: 初期化");
  }
 
  log(message: string): void {
    console.log(`[LOG] ${message}`);
  }
}
 
@injectable()
class PostgresDatabase implements Database {
  constructor(@inject(TYPES.Logger) private logger: Logger) {
    this.logger.log("PostgresDatabase: 初期化");
  }
 
  async query(sql: string): Promise<any> {
    this.logger.log(`Executing: ${sql}`);
    return [];
  }
}
 
// DI コンテナでライフタイムを制御
const container = new Container();
 
container
  .bind<Logger>(TYPES.Logger)
  .to(ConsoleLogger)
  .inSingletonScope();   // ← コンテナが1インスタンスを保証
 
container
  .bind<Database>(TYPES.Database)
  .to(PostgresDatabase)
  .inSingletonScope();
 
// 取得
const logger1 = container.get<Logger>(TYPES.Logger);
const logger2 = container.get<Logger>(TYPES.Logger);
console.log(logger1 === logger2); // true
 
// テスト時はモックに差し替え可能
const testContainer = new Container();
testContainer.bind<Logger>(TYPES.Logger).toConstantValue({
  log: jest.fn(),
});

// Singleton + Factory: レジストリパターン
class PluginRegistry {
  private static instance: PluginRegistry;
  private plugins = new Map<string, () => Plugin>();
 
  private constructor() {}
 
  static getInstance(): PluginRegistry {
    if (!this.instance) {
      this.instance = new PluginRegistry();
    }
    return this.instance;
  }
 
  register(name: string, factory: () => Plugin): void {
    this.plugins.set(name, factory);
  }
 
  create(name: string): Plugin {
    const factory = this.plugins.get(name);
    if (!factory) throw new Error(`Unknown plugin: ${name}`);
    return factory();
  }
}
 
// Singleton + Observer: イベントバス
class EventBus {
  private static instance: EventBus;
  private listeners = new Map<string, Set<Function>>();
 
  private constructor() {}
 
  static getInstance(): EventBus {
    if (!this.instance) {
      this.instance = new EventBus();
    }
    return this.instance;
  }
 
  on(event: string, handler: Function): void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event)!.add(handler);
  }
 
  emit(event: string, data?: any): void {
    this.listeners.get(event)?.forEach(handler => handler(data));
  }
}

// 実務的な Singleton コネクションプール
import { Pool, PoolConfig } from 'pg';
 
class DatabasePool {
  private static pool: Pool | null = null;
 
  static getPool(): Pool {
    if (!DatabasePool.pool) {
      const config: PoolConfig = {
        host: process.env.DB_HOST ?? 'localhost',
        port: Number(process.env.DB_PORT ?? 5432),
        database: process.env.DB_NAME ?? 'myapp',
        user: process.env.DB_USER ?? 'postgres',
        password: process.env.DB_PASSWORD,
        max: 20,                    // 最大コネクション数
        idleTimeoutMillis: 30000,   // アイドルタイムアウト
        connectionTimeoutMillis: 2000, // 接続タイムアウト
      };
 
      DatabasePool.pool = new Pool(config);
 
      // エラーハンドリング
      DatabasePool.pool.on('error', (err) => {
        console.error('Unexpected pool error:', err);
      });
 
      console.log('DatabasePool: 初期化完了 (max=20)');
    }
    return DatabasePool.pool;
  }
 
  // テスト用: プールをリセット
  static async reset(): Promise<void> {
    if (DatabasePool.pool) {
      await DatabasePool.pool.end();
      DatabasePool.pool = null;
    }
  }
}
 
// 使用
async function getUsers() {
  const pool = DatabasePool.getPool();
  const result = await pool.query('SELECT * FROM users');
  return result.rows;
}

// 環境別の設定を Singleton で管理
type Environment = 'development' | 'staging' | 'production';
 
interface AppSettings {
  readonly env: Environment;
  readonly apiBaseUrl: string;
  readonly logLevel: 'debug' | 'info' | 'warn' | 'error';
  readonly enableMetrics: boolean;
  readonly maxRetries: number;
}
 
const settings: Record<Environment, AppSettings> = {
  development: {
    env: 'development',
    apiBaseUrl: 'http://localhost:3000',
    logLevel: 'debug',
    enableMetrics: false,
    maxRetries: 1,
  },
  staging: {
    env: 'staging',
    apiBaseUrl: 'https://staging-api.example.com',
    logLevel: 'info',
    enableMetrics: true,
    maxRetries: 3,
  },
  production: {
    env: 'production',
    apiBaseUrl: 'https://api.example.com',
    logLevel: 'warn',
    enableMetrics: true,
    maxRetries: 5,
  },
};
 
const env = (process.env.NODE_ENV as Environment) ?? 'development';
export const appSettings: Readonly<AppSettings> = Object.freeze(settings[env]);

// Java: デシリアライゼーションで Singleton が破壊される例
public class Singleton implements Serializable {
    private static final Singleton INSTANCE = new Singleton();
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        return INSTANCE;
    }
 
    // これがないと、デシリアライズ時に新インスタンスが生成される
    // readResolve() で既存インスタンスを返すことで防御
    private Object readResolve() {
        return INSTANCE;
    }
}

// 攻撃コード
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton s2 = constructor.newInstance(); // private constructor を迂回！
 
// 防御策: コンストラクタ内でチェック
private Singleton() {
    if (INSTANCE != null) {
        throw new IllegalStateException("Singleton already initialized");
    }
}

// Jest でモジュールキャッシュがリセットされる問題
 
// config.ts
export const config = { value: "original" };
 
// test1.spec.ts
import { config } from './config';
config.value = "modified";  // テスト中に変更
 
// test2.spec.ts
import { config } from './config';
console.log(config.value);  // "original" or "modified"?
// Jest の --isolateModules 設定によって異なる
 
// 対策: テストごとにリセットメカニズムを提供
export function resetConfig(): void {
  Object.assign(config, defaultConfig);
}

// NG: 何でも詰め込む「神」シングルトン
class AppState {
  private static instance: AppState;
 
  user: User | null = null;
  theme: string = "light";
  cart: CartItem[] = [];
  notifications: Notification[] = [];
  searchHistory: string[] = [];
  recentProducts: Product[] = [];
  // ... 50以上のプロパティ
 
  static getInstance(): AppState {
    if (!this.instance) this.instance = new AppState();
    return this.instance;
  }
}
 
// 使用側: あらゆるモジュールが AppState に依存
function processOrder() {
  const state = AppState.getInstance();
  state.cart;           // カート機能が依存
  state.user;           // ユーザー機能が依存
  state.notifications;  // 通知機能が依存
}

// OK: ドメインごとに分割し、DI コンテナで管理
interface UserState {
  currentUser: User | null;
  login(credentials: Credentials): Promise<void>;
  logout(): void;
}
 
interface CartState {
  items: CartItem[];
  addItem(item: CartItem): void;
  removeItem(id: string): void;
}
 
interface NotificationState {
  notifications: Notification[];
  add(n: Notification): void;
  markRead(id: string): void;
}
 
// 各状態を独立して管理
container.bind<UserState>(TYPES.UserState).to(UserStateImpl).inSingletonScope();
container.bind<CartState>(TYPES.CartState).to(CartStateImpl).inSingletonScope();
container.bind<NotificationState>(TYPES.NotificationState).to(NotificationStateImpl).inSingletonScope();

// NG: テスト間で Singleton の状態がリークする
class Counter {
  private static instance: Counter;
  private count = 0;
 
  private constructor() {}
 
  static getInstance(): Counter {
    if (!this.instance) this.instance = new Counter();
    return this.instance;
  }
 
  increment(): void { this.count++; }
  getCount(): number { return this.count; }
}
 
// テスト（NG）
describe("feature A", () => {
  it("increments counter", () => {
    Counter.getInstance().increment();
    Counter.getInstance().increment();
    expect(Counter.getInstance().getCount()).toBe(2); // Pass
  });
});
 
describe("feature B", () => {
  it("starts at zero", () => {
    // 前のテストの状態が残っている！
    expect(Counter.getInstance().getCount()).toBe(0); // FAIL: 2
  });
});

// OK: リセットメカニズムを提供する
class Counter {
  private static instance: Counter;
  private count = 0;
 
  private constructor() {}
 
  static getInstance(): Counter {
    if (!this.instance) this.instance = new Counter();
    return this.instance;
  }
 
  increment(): void { this.count++; }
  getCount(): number { return this.count; }
 
  // テスト用リセット（本番コードでは呼ばない）
  static resetForTesting(): void {
    this.instance = undefined as any;
  }
}
 
// テスト（OK）
beforeEach(() => {
  Counter.resetForTesting();
});

// NG: コンストラクタで外部リソースに接続
class ApiClient {
  private static instance: ApiClient;
  private connection: WebSocket;
 
  private constructor() {
    // コンストラクタで WebSocket 接続を開始
    // → いつ getInstance() が呼ばれるか制御できない
    // → テストで実際の接続が発生する
    this.connection = new WebSocket("wss://api.example.com");
  }
 
  static getInstance(): ApiClient {
    if (!this.instance) this.instance = new ApiClient();
    return this.instance;
  }
}

// OK: 明示的な初期化メソッドを分離
class ApiClient {
  private static instance: ApiClient;
  private connection: WebSocket | null = null;
 
  private constructor() {}
 
  static getInstance(): ApiClient {
    if (!this.instance) this.instance = new ApiClient();
    return this.instance;
  }
 
  async connect(url: string): Promise<void> {
    this.connection = new WebSocket(url);
    await this.waitForOpen();
  }
 
  private waitForOpen(): Promise<void> {
    return new Promise((resolve, reject) => {
      this.connection!.onopen = () => resolve();
      this.connection!.onerror = (e) => reject(e);
    });
  }
}
 
// 使用: 初期化タイミングを制御できる
const client = ApiClient.getInstance();
await client.connect("wss://api.example.com");

// === あなたの実装をここに書いてください ===
 
// ヒント: 以下のインタフェースを満たすこと
interface ILogger {
  debug(message: string): void;
  info(message: string): void;
  warn(message: string): void;
  error(message: string): void;
  getHistory(): string[];
}

// === あなたの実装をここに書いてください ===
 
// ヒント: 以下のインタフェースを満たすこと
interface ConfigManager {
  get<T>(key: string): T;
  get<T>(key: string, defaultValue: T): T;
  set(key: string, value: unknown): void;
  getEnvironment(): string;
  toJSON(): Record<string, unknown>;
}

// === あなたの実装をここに書いてください ===
 
// ヒント: 以下のインタフェースを満たすこと
interface ICacheService {
  get<T>(key: string): Promise<T | null>;
  set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
  delete(key: string): Promise<boolean>;
  clear(): Promise<void>;
}

// 隠れた依存の例
function processOrder(order: Order): void {
  // 関数のシグネチャからは Database と Logger への依存が見えない
  const db = Database.getInstance();      // 隠れた依存
  const logger = Logger.getInstance();    // 隠れた依存
 
  db.save(order);
  logger.info(`Order ${order.id} processed`);
}
 
// DI で明示的にする
function processOrder(
  order: Order,
  db: IDatabase,       // 依存が明示的
  logger: ILogger      // 依存が明示的
): void {
  db.save(order);
  logger.info(`Order ${order.id} processed`);
}