java设计模式-单例模式

模式导读:

单例模式：保证一个类只有一个实例，并且能够提供一个访问该实例的全局访问点。

优点：由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置，产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

参考类图:

代码实现:

常见的五种单例模式实现方式:

主要：

  饿汉式：线程安全，调用效率高，不能延时加载。

package com.etc;

//饿汉式单例模式，不可延时加载，调用效率高
public class HungrySingleton {
    // 类初始化时立即加载这个对象，加载类时天然的是线程安全的
    private static HungrySingleton instance = new HungrySingleton();

    // 让构造器为 private，这样该类就不会被实例化
    private HungrySingleton() {
    }

    // 获取唯一可用的对象，方法没有同步，调用效率高
    public static HungrySingleton getInstance() {
        return instance;
    }

    public void showMessage() {
        System.out.println("饿汉式单例模式测试输出:立即加载!");
    }
}

 懒汉式：线程安全，调用效率不高，可以延时加载。

package com.etc;
//懒汉式单例模式
public class LazySingleton {
    //类初始化时，不初始化对象,延时加载
    private static LazySingleton instance=null;
    //私有化构造器
    private LazySingleton() {
        
    }
    //设置了方法同步，每次调用该方法都要同步，并发效率低，资源利用率高
    public synchronized static LazySingleton getInstance() {
        //当需要使用时再初始化类对象
        if(instance==null) {
            instance=new LazySingleton();
        }
        return instance;
    }
    public void showMessage() {
        System.out.println("懒汉式单例模式测试输出:延时加载！");
    }
}

其他：

 双重检测锁式：由于JVM底层内部模型原因，偶尔会出问题，不建议使用。

package com.etc;
//双重检测锁式单例模式
public class DCClockSingleton {

    public static DCClockSingleton instance=null;
    //私有化构造器
    private DCClockSingleton() {

    }
    //将同步内容下放到if内部，提高了执行的效率，不必每次获取对象都进行同步，只有第一次才同步创建了以后就不必同步
    public static DCClockSingleton getInstance() {
        if(instance ==null) {
            DCClockSingleton ds;
            //第一重检测锁
            synchronized(DCClockSingleton.class) {
                ds=instance;
                if(ds==null) {
                    //第二重检测锁
                    synchronized(DCClockSingleton.class) {
                        if(ds==null) {
                            ds=new DCClockSingleton();
                        }
                    }
                    instance=ds;
                }
            }
        }
        return instance;
    }
    public void showMessage() {
        System.out.println("双重检测锁单例模式测试输出:延时加载!");
    }
}

  静态内部类式：线程安全，调用效率高，可以延时加载。

package com.etc;
//静态内部类单例模式
public class StaticNativeClassSingleton {
    //私有化构造器
    private StaticNativeClassSingleton() {
    }
    //静态内部类，实现类的延时加载
    private static class InstanceSingleton{
        private static final StaticNativeClassSingleton instance=new StaticNativeClassSingleton();
    }
    //方法未同步，效率高
    public static  StaticNativeClassSingleton getInstance() {
        return InstanceSingleton.instance;
    }
    public void showMessage() {
        System.out.println("静态内部类单例模式测试输出:延时加载!");
        
    }
}

  枚举单例：线程安全，调用效率高，不能延时加载。

package com.etc;
//枚举单例模式
public enum EnumSingleton {
    //枚举元素本身就是代表单例对象
    instance;
    public void showMessage() {
        System.out.println("枚举单例模式测试输出:立即加载!");
    }
}

ps:测试类

package com.etc;

public class SingletonTest {

    public static void main(String[] args) {
        //饿汉式单例模式测试输出
        HungrySingleton hungry=HungrySingleton.getInstance();
        hungry.showMessage();
        //懒汉式单例模式测试输出
        LazySingleton lazy=LazySingleton.getInstance();
        lazy.showMessage();
        //双重检测锁单例模式测试输出
        DCClockSingleton dcclock=DCClockSingleton.getInstance();
        dcclock.showMessage();
        //静态内部类单例模式测试输出
        StaticNativeClassSingleton sns=StaticNativeClassSingleton.getInstance();
        sns.showMessage();
        //枚举单例模式测试输出
        EnumSingleton e=EnumSingleton.instance;
        e.showMessage();
        
    }
}

效果截图:

单例模式优缺点:

优点:

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。
2、避免对资源的多重占用。

缺点：

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

适用场景：

1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。