JAVA デザインパターンシングルトンパターン-＆＃＆チュートリアル-php.cn

この記事では、23 のデザインパターンシリーズのシングルトンパターンを引き続き紹介します。

概念:
シングルトンパターンは、Java の一般的な設計パターンです。シングルトンパターンを記述するには、主に 3 つのタイプがあります: 遅延スタイルシングルトン、および登録スタイルシングルトン。
シングルトンパターンには以下の特徴があります:
1. シングルトンクラスはインスタンスを 1 つだけ持つことができます。
2. シングルトンクラスは独自の一意のインスタンスを作成する必要があります。
3. シングルトンクラスは、このインスタンスを他のすべてのオブジェクトに提供する必要があります。
シングルトンパターンは、クラスがインスタンスを 1 つだけ持つことを保証し、クラス自体をインスタンス化し、このインスタンスをシステム全体に提供します。コンピュータシステムでは、スレッドプール、キャッシュ、ログオブジェクト、ダイアログボックス、プリンタ、グラフィックカードドライバオブジェクトはシングルトンとして設計されることがよくあります。これらのアプリケーションはすべて、多かれ少なかれリソースマネージャーの機能を備えています。各コンピュータには複数のプリンタを搭載できますが、2 つの印刷ジョブが同時にプリンタに出力されることを防ぐために、存在できるプリンタスプーラは 1 つだけです。各コンピュータは複数の通信ポートを持つことができ、システムはこれらの通信ポートを集中管理して、1 つの通信ポートが 2 つの要求によって同時に呼び出されないようにする必要があります。つまり、シングルトンモードを選択する目的は、矛盾した状態を回避し、長期的なポリシーを回避することです。

1. Lazy Singleton

//懒汉式单例类.在第一次调用的时候实例化自己   
public class Singleton {  
    private Singleton() {}  
    private static Singleton single=null;  
    //静态工厂方法   
    public static Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
}

ログイン後にコピー

Singleton は、構築メソッドをプライベートに制限することで、クラスが外部からインスタンス化されるのを回避します。同じ仮想マシンのスコープ内では、Singleton の唯一のインスタンスには getInstance() メソッドを通じてのみアクセスできます。。

(実際、Java リフレクションメカニズムを通じて、プライベートコンストラクターを使用してクラスをインスタンス化することができます。これにより、基本的にすべての Java シングルトン実装が無効になります。この問題についてはここでは説明しません。リフレクションメカニズムは無視しましょう。 )

しかし、上記の遅延スタイルのシングルトン実装では、スレッド安全性の問題が考慮されていません。スレッド安全性を実現するには、次の 3 つの方法があります。遅延スタイルシングルトンのスレッドセーフを確保するための getInstance メソッドの変更。シングルトンモデルを初めて使用し、スレッドセーフについてよく知らない場合は、次の 3 つの小さな項目をスキップして、遅延スタイルに進んでください。たとえば、読み終わるまで待ってから、スレッドの安全性の問題を検討してください:

1. getInstance メソッドに同期を追加します

public static synchronized Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
}

ログイン後にコピー

2. 静的内部クラスを再確認します

public static Singleton getInstance() {  
        if (singleton == null) {    
            synchronized (Singleton.class) {    
               if (singleton == null) {    
                  singleton = new Singleton();   
               }    
            }    
        }    
        return singleton;   
    }

ログイン後にコピー

これは上記の 1 と 2 よりも優れており、スレッドの安全性を実現するだけでなく、同期によるパフォーマンスへの影響も回避できます。

2. Hungry スタイルのシングルトン

public class Singleton {    
    private static class LazyHolder {    
       private static final Singleton INSTANCE = new Singleton();    
    }    
    private Singleton (){}    
    public static final Singleton getInstance() {    
       return LazyHolder.INSTANCE;    
    }    
}

ログイン後にコピー

Hungry-Han スタイルは、クラスの作成時にシステムで使用する静的オブジェクトをすでに作成しており、将来的には変更しないため、本質的にスレッドセーフです。

3. 登録されたシングルトン (無視できます)

//饿汉式单例类.在类初始化时，已经自行实例化   
public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态工厂方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
}

ログイン後にコピー

登録されたシングルトンは、実際にはシングルトンクラスのインスタンスのセットを維持し、これらのインスタンスを Map (登録ブック) に保存します。登録されている場合は、マップから直接返されます。登録されていない場合は、最初に登録されてから返されます。

ここでは、登録スタイルのシングルトンを無視できるものとしてマークしました。さらに、静的メソッドブロックとそのシングルトンのため、内部実装では依然として中国スタイルのシングルトンが使用されています。クラスがロードされるときにインスタンス化されます。

ハングリーマンスタイルとレイジーマンスタイルの違い

ハングリーマンとレイジーマンという名前から、

ハングリーマンは、クラスがロードされると、getInstance時に確実にシングルトンが初期化されることを意味します。シングルトンはすでに存在しますはい、

怠け者は怠け者で、getInstance が呼び出されたときにのみシングルトンの初期化に戻ります。

さらに、次の 2 つのメソッドは次の 2 つの点で区別されます:

1. スレッドセーフ:

Hungry Chinese スタイルは本質的にスレッドセーフであり、問題なくマルチスレッドに直接使用できます。

遅延スタイル自体はスレッドセーフではありません。スレッドセーフを実現するにはいくつかの方法があります。つまり、上記 1、2、および 3 には、リソースの読み込みとパフォーマンスにいくつかの違いがあります。

2. リソースの読み込みとパフォーマンス:

Hungry Chinese スタイルは、このシングルトンが後で使用されるかどうかに関係なく、一定量のメモリを占有します。リソースが初期化されているため、初めて呼び出されたときの速度は速くなります

。また、名前が示すように、遅延スタイルでは読み込みが遅延し、最初にシングルトンが実行されるまでオブジェクトはインスタンス化されません。最初の初期化は最初の呼び出し時に実行する必要があり、実行する作業が多い場合、パフォーマンスに多少の遅延が発生し、空腹の中国スタイルと同じになります。

3 つの実装 1、2、3 にはいくつかの違いがあります

1 つ目はメソッド呼び出しに同期を追加しますが、毎回同期が必要になるため、結局のところパフォーマンスに影響します。 , 99% の場合、同期は必要ありません

2 番目のタイプでは、シングルトンが初めて呼び出されたときにのみ同期が実行されるようにするために、getInstance で 2 つの null チェックが実行されます。 -safe で、同時同期によるパフォーマンスの損失を回避します

3 番目のメソッドは、クラスローダーメカニズムを使用して、インスタンスの初期化時にスレッドが 1 つだけであることを保証するため、スレッドセーフでパフォーマンスの損失がありません。これを使うには。

什么是线程安全？

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

或者说：一个类或者程序所提供的接口对于线程来说是原子操作，或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题，那就是线程安全的。

应用

以下是一个单例类使用的例子，以懒汉式为例，这里为了保证线程安全，使用了双重检查锁定的方式：

public class TestSingleton {  
    String name = null;  
  
        private TestSingleton() {  
    }  
  
    private static volatile TestSingleton instance = null;  
  
    public static TestSingleton getInstance() {  
           if (instance == null) {    
             synchronized (TestSingleton.class) {    
                if (instance == null) {    
                   instance = new TestSingleton();   
                }    
             }    
           }   
           return instance;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public void printInfo() {  
        System.out.println("the name is " + name);  
    }  
  
}

ログイン後にコピー

可以看到里面加了volatile关键字来声明单例对象，既然synchronized已经起到了多线程下原子性、有序性、可见性的作用，为什么还要加volatile呢，原因已经在下面评论中提到，

还有疑问可参考http://www.iteye.com/topic/652440
和http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

public class TMain {  
    public static void main(String[] args){  
        TestStream ts1 = TestSingleton.getInstance();  
        ts1.setName("jason");  
        TestStream ts2 = TestSingleton.getInstance();  
        ts2.setName("0539");  
          
        ts1.printInfo();  
        ts2.printInfo();  
          
        if(ts1 == ts2){  
            System.out.println("创建的是同一个实例");  
        }else{  
            System.out.println("创建的不是同一个实例");  
        }  
    }  
}

ログイン後にコピー

运行结果：

JAVA デザインパターンシングルトンパターン