Singleton パターンを例でわかりやすく解説

目的

クラスのインスタンスが1つだけであることを保証し、そこへのグローバルなアクセス点を提供します。Singleton パターンは、Gang of Four（GoF）の書籍にある5つの生成パターンの1つです。

解決する問題

プログラム内にちょうど1つだけ存在すべきオブジェクトがあります。環境変数から読み込むアプリケーション設定、プロセス内キャッシュ、データベース接続のプールなどです。すべてのモジュールが new Config() を呼ぶと、そのたびに環境変数を読み直し、キャッシュは多数のコピーに分裂し、プールの上限も意味を失います。

必要なのは2つです。誤って2つ目のインスタンスを作れないという保証と、どのコードからもその唯一のインスタンスに簡単に到達できる手段です。

構造と登場要素

TypeScriptでの実装

プライベートなコンストラクタにより、クラスの外での new AppConfig() はコンパイルエラーになります。静的メソッドが、オブジェクトを遅延して作成します。

class AppConfig {
  private static instance: AppConfig | undefined;
  readonly settings: Record<string, string>;
  private constructor() {
    console.log("loading config once");
    this.settings = { mode: "production", region: "eu" };
  }
  static getInstance(): AppConfig {
    if (!AppConfig.instance) {
      AppConfig.instance = new AppConfig();
    }
    return AppConfig.instance;
  }
}
const a = AppConfig.getInstance(); // loading config once
const b = AppConfig.getInstance();
console.log(a === b);          // true
console.log(a.settings.mode);  // production
// new AppConfig(); // error: constructor is private

JavaScriptとTypeScriptでは、ESモジュールはプログラムごとに1回だけ評価されるので、モジュールからインスタンスをエクスポートするのが最も簡単なSingletonです。どの import も同じオブジェクトを受け取ります。

// logger.ts
class Logger {
  private lines: string[] = [];
  log(msg: string): void { this.lines.push(msg); console.log(msg); }
  count(): number { return this.lines.length; }
}
export const logger = new Logger();
// elsewhere: import { logger } from "./logger";
logger.log("started");      // started
console.log(logger.count()); // 1

非同期の初期化

データベース接続を開くときのように、インスタンスの作成が非同期の場合、2つの呼び出し元がどちらも「まだインスタンスがない」と判断し、最初の接続が完了する前に2つの接続を開始してしまうことがあります。結果ではなく、Promiseをキャッシュしましょう。

class Database {
  private static ready: Promise<Database> | undefined;
  private constructor(readonly url: string) {}
  static get(): Promise<Database> {
    if (!Database.ready) {
      Database.ready = (async () => {
        await new Promise((r) => setTimeout(r, 10)); // simulate connecting
        console.log("connected once");
        return new Database("db://main");
      })();
    }
    return Database.ready;
  }
}
const [x, y] = await Promise.all([Database.get(), Database.get()]);
console.log(x === y); // true

JavaやC#のようなマルチスレッド言語では、同じ理由で遅延作成に同期処理が必要です。一般的な解決策は、静的フィールドでの先行初期化、遅延ホルダークラス、Javaでは要素が1つの enum です。

使うべきとき、使わないとき

次の場合はSingleton パターンを使います。

• 利便性のためだけでなく、正しさのためにインスタンスがちょうど1つ必要な場合（1つのハードウェアデバイス、プロセス全体で1つのレジストリなど）。
• 作成コストが高く、作成後のオブジェクトが状態を持たない、またはスレッドセーフな場合。

次の場合は避けるか、使い方を限定します。

• 主な目的が、グローバルに手軽にアクセスすることである場合。Singletonは、見栄えの良い名前を付けたグローバルなミュータブルな状態です。どのコードからでも変更でき、依存関係が関数のシグネチャから見えなくなります。
• テストが必要な場合。Singletonを共有するテストは互いに影響し合い、本物のインスタンスをフェイクに置き換えるのも困難です。
• 「インスタンスは1つ」というルールが後で変わるかもしれない場合。例えば、テナントごとに1つのキャッシュが必要になるときです。

通常の代替案は依存性の注入です。プログラムの開始時（コンポジションルート）にインスタンスを1つ作り、それを必要とするクラスに渡します。インスタンスは1つのままですが、依存関係が見え、置き換えもできます。

class Cache {
  private data = new Map<string, string>();
  get(key: string): string | undefined { return this.data.get(key); }
  set(key: string, value: string): void { this.data.set(key, value); }
}
class UserService {
  constructor(private cache: Cache) {} // dependency is explicit
  remember(id: string, name: string): void { this.cache.set(id, name); }
}
const sharedCache = new Cache(); // the single instance, created once
const users = new UserService(sharedCache);
users.remember("u1", "Ada");
console.log(sharedCache.get("u1")); // Ada

実際の利用例

• Java：Runtime.getRuntime() は、実行中のJavaアプリケーションに対応する唯一の Runtime オブジェクトを返します。
• Node.jsは最初の読み込み後にモジュールをキャッシュするため、モジュールがエクスポートしたオブジェクトは、それをrequireまたはimportするすべてのファイルで共有されます。
• ブラウザーは、ページごとに window や document のような唯一のグローバルオブジェクトを提供します。
• AngularやSpringのような依存性の注入を備えたフレームワークは、既定で「Singletonスコープ」のサービスを作ります。インジェクターまたはコンテナごとに1つのインスタンスで、このパターンの静的アクセスの部分はありません。

関連するパターン

• Abstract Factory パターン、Builder パターン、Prototype パターンのオブジェクトは、ファクトリが1つあれば十分なため、Singletonとして実装されることがよくあります。
• Facade パターンのオブジェクトも、サブシステムへの入口が1つあれば普通は足りるため、単一のインスタンスにすることがよくあります。
• Flyweight パターンもオブジェクトを共有しますが、状態をキーにして多数の共有インスタンスを管理します。Singleton パターンのインスタンスはちょうど1つです。
• 依存性の注入はGoFパターンではありませんが、現代のコードにおけるSingleton パターンの最も一般的な代替策です。