单例模式

定义

Ensure a class has only one instance , and provide a global point of access to it .（确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。）

单例模式是一种对象创建型模式，使用单例模式可以保证为一个类只生成唯一的实例对象。

单例模式的三个要点：

• 一个类只能有一个实例；
• 必须自行创建这个实例；
• 必须自行向整个系统提供这个实例。

单例模式的通用UML图如下：

单例模式.jpg

单例模式的常见两种形式的代码如下：

//“饿汉式”单例模式
public class Singleton{
    private static final Singleton singleton = new Singleton();
    //限制生产多个对象
    private Singleton(){

    }

    //通过该方法获得实例对象
    public static Singleton getSingleton(){
        return singleton;
    }

    //其他方法
    public static void doSomething(){
    
    }
}

//"懒汉式"单例模式
public class Singleton{
    private static final Singleton singleton;
    //限制生产多个对象
    private Singleton(){

    }

    //通过该方法获得实例对象
    public static Singleton getSingleton(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }

    //其他方法
    public static void doSomething(){
    
    }
}

单例模式的优缺点

优点：

• 由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。
• 由于单例模式只生成一个实例，所以减少了系统性能的开销，挡一个对象的产生需要比较多的资源时，则可以通过在应用启动时产生一个单例对象，然后永久驻留内存的方式来解决。
• 单例模式可以避免对资源的多重占用。
• 单例模式可以在系统设置全局的访问点，优化和共享资源访问。

缺点：

• 单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。
• 单例模式对测试是不利的。
• 单例模式与单一职责原则有冲突。

单例模式一般会出现在一下情况中：

• 要求生成唯一序列号的环境；
• 在多个线程之间，如servlet环境，共享同一个资源或者操作同一个对象；
• 在整个程序空间使用全局变量共享资源；
• 在大规模系统中，为了性能的考虑，需要节省对象的创建时间；
• 需要定义大量的静态常量和静态方法的环境；
• 创建一个对象需要消耗的资源过多。

单例模式的注意事项

• 在高并情况下，需要注意单例模式的线程同步问题。上面所示“懒汉式”单例模式就需要考虑线程同步。
  为什么会出现这种情况呢？
  假如一个线程A执行到singleton = new Singleton()，但还没有获得对象（对象初始化是需要时间的），第二个线程B也在执行，执行到（singleton==null）判断，那么线程B获得判断条件也是为真，于是继续运行下去，线程A获得了一个对象，线程B也获得了一个对象，在内存中就出现了两个对象。

为了解决多线程问题，采用了对函数进行同步的方式，但是比较浪费资源，因为每次都需要进行同步检查。代码如下：

public class Singleton{
    private static final Singleton singleton;
    //限制生产多个对象
    private Singleton(){

    }

    //通过该方法获得实例对象
    public static synchronized Singleton getSingleton(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }

    //其他方法
    public static void doSomething(){
    
    }
}

下面的代码则既解决了“懒汉式”的多线程问题，又解决了资源浪费的现象。

public class Singleton{
    private static final Singleton singleton;
    //限制生产多个对象
    private Singleton(){

    }

    //通过该方法获得实例对象
    public static Singleton getSingleton(){
        if(singleton==null){
            synchronized(Singleton.class){
                if(singleton==null){
                    singleton = new Singleton();
                }
            }
        }
        
        return singleton;
    }

    //其他方法
    public static void doSomething(){
    
    }
}

单例模式的扩展

需要产生固定数量对象的模式是有上限的多例模式，它是单例模式的一种扩展。代码如下：

public class Emperor{
    //定义最多能产生的实例数量
    private static int maxNumOfEmperor = 2;
    //使用ArrayList来容纳每个对象的私有属性
    private static ArrayList<String> nameList = new ArrayList<String>();
    //定义一个列表，容纳所有的实例
    private static ArrayList<Emperor> emperorList = new ArrayList<Emperor>();
    //当前对象的序列号
    private static int countNumOfEmperor = 0；
    //产生所有的对象
    static{
        for(int i=0,i<maxNumOfEmperor;i++){
            emperorList.add(new Emperor("皇"+(i+1)+"帝"));
        }
    }
    //私有化构造方法
    private Emperor(){

    }
    private Emperor(String name){
        nameList.add(name);
    }
    //随机获得一个皇帝对象
    public static Emperor getInstance(){
        Random random =new Random();
        countNumOfEmperor = random.nextInt(maxNumOfEmperor);
        return emperorList.get(countNumOfEmperor);
    }
}

好的，就这样。

我的微信公众号.jpg