设计模式--单例模式

1、单例模式

单例模式就是保证一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。（建议采用 饿汉式 创建方法。线程安全，容易实现。初始化慢一点。）

1.1、单例模式的优点：

1，由于单例模式只生成一个实例，所以能减少系统性能的开销；

2，避免对共享资源的多重占用导致的性能损耗，如日志文件，应用配置；

3，提供了对唯一实例的受控访问，加快对象访问速度，比如多线程的线程池的设计，方便对池中的线程进行控制；

1.2、单例模式的特点：

1，保证一个类只有一个实例；

2，在类中自己实例化自己；

3，向整个系统提供这个实例；

1.3、单例模式的实现方式：

• 饿汉式单例模式：

/**
 * 饿汉式单例模式
 */
public class Singleton01 {
    /**类加载时，立即加载这个对象，也是叫饿汉的原因
     * 这也保证了线程的安全
     * -------------->在类中自己实例化自己；
     */
    private static Singleton01 singleton01=new Singleton01();

    /**私有构造器
     * ------------>保证一个类只有一个实例
     */
    private Singleton01() {
    }

    /**因为不需要加同步代码块就能保证线程安全，所以效率会高
     * --------------->向整个系统提供这个实例；
     * @return
     */
    public Singleton01 getSingleton01(){
        return singleton01;
    }
}

可以看出，饿汉式的优点有，线程安全，调用效率高；但因为加载类时立即实例化，所以没有延时加载的优势，并且当没有用到这个实例的话，就会白白实例化个对象，浪费资源。

 

• 懒汉式单例模式：

 

/**
 * 懒汉式单例模式
 */
public class Singleton02 {

    /**
     *提供静态属性，加载类时不会实例化对象
     */
    private static Singleton02 singleton02;

    /**
     * 私有构造器
     */
    private Singleton02() {
    }
    /**
     * 第一次调用时才会实例化对象，并且之后不会再实例化，直接返回第一次创建的对象
     * 通过添加关键字synchronized来保证线程安全，但线程等待的缘故所以效率会降低
     * 只有用到才创建对象，所以叫懒汉式，故而资源利用率高了
     */
    public static synchronized Singleton02 getSingleton02(){
        if (singleton02==null){
            singleton02=new Singleton02();
        }
        return singleton02;
    }
}

 

可以看出，懒汉式单例模式的优点有:资源利用率高了，有延时加载的优势，线程安全；但调用效率低。

• 静态内部类式单例模式：

//静态内部类方式
public class Singleton03 {

    /**在调用getInstance()才会加载，同时立即实例化对象，所有线程安全，且有延时加载的优势
     * 在静态内部类中实例化对象
     */
    private static class singletonClassInstance{
        private static final Singleton03 instance=new Singleton03();
    }
    /**
     * 私有构造器
     */
    private Singleton03() {
    }
    public static Singleton03 getInstance(){
        return singletonClassInstance.instance;
    }
}

总结下，静态内部类方式的优点：线程安全，具有延时加载的优势，资源利用率也搞，而且没有使用同步代码，效率还高。

 

• 枚举式单例模式

//枚举式单例模式
public enum Singleton04 {
     //这个枚举元素，本身就是单例对象
    INSTANCE;
    //添加自己需要的操作
    public void singletonOperation(){
    }
}

 

总结：实现简单，枚举本身就是单例，由JVM从根本上提供保障，避免通过反射和反序列化的漏洞！但没有延迟加载！

可以自行测试下，其实还有个双重检验锁式单例模式，但偶尔会出问题，实用性比较低，也不推荐实用，这里就不讲了。

• 如何选择上面几种单例模式的：

1，占用资源少，不需要延时加载，枚举式好如饿汉式；

2，占用资源多，需要延时加载，静态内部类式好于懒汉式；