Singletonパターン

グローバル変数の代用？

Singletonパターンは、デザインパターンの中でも最も分かりやすいので、初学者は濫用しがちだ。

あるクラスFooをSingletonにすると、アプリケーションの随所で、次のようにして使うことができる。

Foo* foo = Foo::GetInstance();
foo->bar();
        

ふつうのオブジェクトは、どこで生成して、どこで保持して、…ということを、きちんと考えないといけない。いろいろな箇所で使う場合は、関数やクラスの間で、オブジェクトを受け渡してあげないといけない。

ところが、Singletonは、そのようなことをまったく考えずに、アプリケーションのどこでも自由に使える。

これは、よく考えてみると、次のようなコードと同じである。

extern Foo foo;         // グローバル変数

〜〜〜〜〜〜〜〜〜

foo.bar();
        

つまり、グローバル変数の代用として、Singletonパターンを使ってしまっているケースがある。

変数をグローバルに宣言してしまえば、どこからでも参照できるので、手軽である。そのため、プログラミングの初心者には、グローバル変数を多用したがる人もいる。

グローバル変数を多用するのが誤った考えであることは、大抵の人は理解している。にも関わらず、グローバル変数の代用として、Singletonパターンを使っているケースが、少なくない。

この背景には、「デザインパターンを使っていないものより、使っているものの方が、良い設計である」と誤解されていることもあるようだ。デザインパターンを使っているだけで、何か良いことをしているような気になってしまうこともありそうだ。

だが、誤ったSingletonパターンの濫用は、グローバル変数を多用した場合と、結局はまったく同じことをしている。むしろ、グローバル変数を多用するよりも、害が大きいとも言える。というのも、Singletonパターンを使うと、インスタンスが１つしか存在しない、という制約が、クラスの制約になってしまうためだ。単純にグローバル変数を使う場合は、クラスにはその制約はない。

実際、いろいろな箇所でSingletonパターンを使っているケースを目にする。だが、本当にSingletonパターンを使うべきケースというのは、相当に少ないはずだ。

Singletonパターンを使うべきでない例

Ｎ体問題のシミュレーションをしているとしよう。Ｎ個の天体の初期位置や初速度を適当に指定してシミュレーションを実行した結果を、１つのデータセットとして保存する。初期位置や初速度を変えつつ、何度もシミュレーションを行うと、大量のデータセットができる。

そこで、シミュレーション結果を表示するアプリケーションを作ろう。アプリケーションでは、データセットを１つロードすると、初期状態や終了状態を画面に表示できるものとする。天体の空間密度の時間変化や、各天体の軌跡のパターンなど、いろいろなデータを表示するだろうし、さまざまな解析も可能だろう。このアプリケーションは、たくさんの画面を持つことになる。

実際にこのアプリケーションを作ってみると、おそらく、非常にたくさんの画面が、相互に関係しあう、非常に複雑なシステムになると思われる。それらの画面は、ほぼすべて、ロードされたデータセットにアクセスするだろう。しかも、このアプリケーションでは、１つしかデータセットをロードできない、と決まっている。

このようなケースで、データセットを表すクラスを、Singletonとしてデザインしてしまうことがある。しかし、これは誤りだ。

データセットのクラスは、おそらく、次のようなデータの集合となるだろう。

• シミュレーション実行日時。
• Ｎ個の天体の初期位置と初速度。
• シミュレーション終了時のＮ個の天体の状態。
• シミュレーション途中のさまざまな計算結果。

つまり、ただのデータである。

このデータセットが、常に１つしかロードされていない（メモリ上に１つしか存在しない）というのは、アプリケーションレベルの仕様である。ただのデータの集まりである、データセットのクラスだけを見れば、これが必ず１つしか存在してはいけない、という理由は存在しない。

データセットのクラスをSingletonにしてしまう、ということは、アプリケーションレベルの仕様を、誤って下位レベルのクラスに組み込んでしまう、ということになる。この場合は、データセットの実体を、グローバル変数として１つだけ持たせる方が、はるかに正しい設計となる。

Singletonパターンを使う目的

Singletonパターンは、実装者が誤ってインスタンスを生成しようとしてもできない、という点が、利点として挙げられることが多いが、必ずしも正しくないように思う。

たとえ、あるクラスをSingletonにしたとしても、実装者が次のような誤りを犯せば、アプリケーションは正しく動作しなくなる。

• Singletonクラスを使わないで、独自に処理してしまう。
  • 後述する、PIXYシステム2のXmlDBHolderCacheクラスの例で言えば、次のようなケースである。
    • XmlDBHolderCacheクラスを使わずに、ダイレクトにデータベース内のXMLファイルにアクセスしてしまう。
• Singletonクラスとまったく同じ機能を持つクラスをもう１つ作って、そちらを使ってしまう。

Singletonパターンを使う目的は、実装者の誤りを防ぐことではない。そのクラスを見た人が分かるように、インスタンスを１つしか生成しないことを前提としてクラスが実装されていることを「表現」することにある。

つまり、Singletonパターンを使う目的は、そのクラスだけに閉じている。この点からも、アプリケーションレベルで、インスタンスが１つしかない、という仕様がある場合に、それをSingletonパターンとして設計するのは、誤りと言える。

コピーコンストラクタに関する注意

Singletonパターンでは、勝手にいくつものインスタンスを作れないように、コンストラクタをprivateにする。

C++の場合は、引数を持たないデフォルトコンストラクタの他に、コピーコンストラクタも暗黙のうちに作られているので、注意が必要である。

プログラミングの禁じ手Web版 C++編「使われたくない暗黙のメンバ関数を未定義にしない 」

C++でSingletonパターンを使う際は、コピーコンストラクタも明示的に宣言し、privateにしなければならない。

下記のFooクラスは、一見すると、Singletonパターンになっているように見える。

class Foo {
public:
        int value;

private:
        static Foo* foo;

        Foo ( ) {
                value = 0;
        }

        virtual ~Foo ( ) {
        }

public:
        static Foo* getInstance ( ) {
                if (foo == NULL)
                        foo = new Foo();

                return foo;
        }
};

Foo* Foo::foo = NULL;
        

だが、コピーコンストラクタがprivateにされていないため、次のようにすると、インスタンスをいくつも作ることができてしまう。

Foo* foo1 = Foo::getInstance();
Foo* foo2 = new Foo(*foo1);

foo1->value = 1;
foo2->value = 2;

printf("foo1 = %d\n", foo1->value);
printf("foo2 = %d\n", foo2->value);
        

実行すると、次のように出力され、インスタンスが２つできたことが分かる。

foo1 = 1
foo2 = 2
        

Singletonオブジェクトの削除

Singletonパターンを使う目的には、下記の２つが考えられる。

• オブジェクトが、たかだか１個しか存在しない、という制約を表す。
• いったん作られた後は、１つのオブジェクトが存在し続ける、という制約を表す。

Singletonパターンでは、インスタンスを取得するメソッドとともに、インスタンスを削除するメソッドも用意することが多い。

class Parent {
private:
        static Parent* parent;

        Parent ( ) {
        }

        Parent ( const Parent& p ) {
        }

        virtual ~Parent ( ) {
        }

public:
        static Parent* getInstance ( ) {
                if (parent == NULL)
                        parent = new Parent();

                return parent;
        }

        static void deleteInstance ( ) {
                if (parent != NULL)
                        delete parent;

                parent = NULL;
        }
};

Parent* Parent::parent = NULL;
        

だがこれは、Singletonパターンを使う目的が、前者の「オブジェクトが、たかだか１個しか存在しない」という制約を表す場合の話だ。後者の「いったん作られた後は、１つのオブジェクトが存在し続ける」という制約を表す場合は、オブジェクトを削除するdeleteInstance()というメソッドは、用意するべきではない。

ここで、C++の場合は、１つの問題が生じる。

getInstance()しか用意しなかった場合は、生成したSingletonオブジェクトが破棄されることがなくなってしまう。例えばVisual C++を使って開発していると、アプリケーションを終了する際に、必ず「メモリリークが発生した」という警告が表示されてしまう。

だがこれは、１つのオブジェクトが存在し続ける、という制約から考えれば、当然の帰結と思われる。

仮に、アプリケーションの終了時に何らかの処理を呼び出す仕組みがあったとしても、そこでSingletonオブジェクトを破棄しても良いものだろうか？ 終了処理とはいえ、実際にはまだアプリケーションは終了している訳ではない。Singletonオブジェクトの破棄をした後で、別のクラスの終了処理から、再度getInstance()が呼ばれてしまう可能性もある。

絶対に、１つのオブジェクトだけが最後まで永続する、という制約を満たすためには、OSがアプリケーションのメモリ領域を解放するまで、つまり、Visual C++の画面にメモリリークと表示されるまで、Singletonオブジェクトは存在しているべきだと思う。

なお、この場合、Singletonクラスのデストラクタに処理を書いても、決して呼び出されないことになるので、注意が必要である。

Singletonクラスを拡張する際の問題

class Parent {
private:
        static Parent* parent;

protected:
        Parent ( ) {
        }

private:
        Parent ( const Parent& p ) {
        }

public:
        static Parent* getInstance ( ) {
                if (parent == NULL)
                        parent = new Parent();

                return parent;
        }
};

class Child : public Parent {
        void foo ( ) {
                // いくらでも作れる。
                Parent* p1 = new Parent();
                Parent* p2 = new Parent();
                Parent* p3 = new Parent();
        }
};

Parent* Parent::parent = NULL;
          

Child* child = Child::getInstance();
          

class Child {
public:
        static Child* getInstance ( ) {
                return (Child*)Parent::getInstance();
        }
};
          

class Child {
private:
        static Child* child;

private:
        Child ( ) {
        }

        Child ( const Child& c ) {
        }

public:
        static Child* getInstance ( ) {
                if (child == NULL)
                        child = new Child();

                return child;
        }
};

Child* Child::child = NULL;
          

PIXYシステム2での、Singletonパターンの使用例

<information>
  <image>ファイル名</image>
  <date>撮影日時</date>
  <center>
    撮影位置
  </center>
    :
</information>
            

<information>
  <image>画像1</image>
    :
</information>
<information>
  <image>画像2</image>
    :
</information>
  :
<information>
  <image>画像100</image>
    :
</information>