设计模式之单例模式

文章结构
1.单例模式简介
2.单例模式种类
3.参考文章


1.单例模式简介

1.1简介

单例模式,从字面上看是“一个实例”,在系统中单例模式的类只允许生成一个实例*。
百度百科的介绍:单例模式,是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中,应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

1.2实现思路

单例模式使得该类只能拥有一个实例,我们会把该类的构造方法私有化,来避免使用者重复创建实例,每当使用者使用该实例的时候我们允许其调用该类的静态方法(getINstance())返回已经创建好的唯一实例;由于将构造方法私有化,该实例的创建也是在该类的方法中完成的,根据单例模式的写法的不同,该实例的创建方式也不同,创建方式主要分为两种“一种是在类加载的时候完成实例的创建,每次获取该实例时返回该对象的引用;第二种则是获取该实例时,先判断该类实例是否存在,不存在就创建一个 ,存在的话就将这个实例的引用传出去”。所以具体实现有两个关键步骤:
1.类的构造方法私有化。
2.类中存在获取该类实例的一个静态方法:getInstance()。

1.3单例模式使用场景:

在系统中仅需要一个全局对象的时候
某个实例调用频繁且创建耗时耗资源的时候
工具类的对象


2.单例模式种类:

单例模式写法主要分为饿汉模式和懒汉模式两种。饿汉模式即在类加载的时候便创建实例,懒汉模式则是在第一次调用该对象的时候生成实例。由于线程安全的原因,懒汉模式存在多中写法,使用者可以根据应用场景选择对应的写法。下面详细介绍每种写法以及优缺点。

2.1:饿汉模式

优缺点:在类加载的时候就完成实例的创建,以后每次调用getInstance()方法会返回该实例的引用。如果该类一直未被调用就会出现资源浪费的情况。

/**
 * 单例模式-饿汉模式
 * @author live
 *
 */
public class Singleton_hungry {
    // 声明私有变量
    private final static Singleton_hungry SINGLETON = new Singleton_hungry();
    // 构造函数私有
    private Singleton_hungry(){};
    // 通过静态方法返回这个单例对象
    public static Singleton_hungry getInstance(){
        return SINGLETON;
    }
}

2.2:懒汉模式-线程不安全

优缺点:该实现方法避免了第一种方法的缺点,当对象被第一次调用的时候才会进行创建,避免了资源的浪费(实现了懒加载);如果在多线程中,该类未被实例化,此时两个线程同时调用getInstance()方法,在一个线程进入了if(singleton == null)代码块,但是还没有执行实例化的时候,第二个线程也通过了if的判断,就会创建两次该实例,违背了单例模式的原则。所以在多线程中慎用这种模式的写法。

/**
 * 单例模式-懒汉模式
 * @author live
 *
 */
public class Singleton_lazy{
    private static Singleton_lazy singleton = null;
    private Singleton_lazy(){};
    public static Singleton_lazy getInstance(){
        // 如果实例未创建,则先创建该实例
        if(singleton == null){
            singleton = new Singleton_lazy();
        }
        return singleton;
    }
}

2.3:懒汉模式-线程安全-同步方法

优缺点:为了避免第二种写法上的缺点,我们在方法上加同步锁,避免在该类未进行实例化的时候两个线程同时调用,这样就不会产生两个实例,但是这种方法会导致以后每次调用该方法都需要等待锁的释放等,效率比较低。

/**
 * 单例模式-懒汉模式
 * 线程安全-同步方法延迟加载
 * @author live
 *
 */
public class Singleton_lazy1{
    private static Singleton_lazy1 singleton = null;
    private Singleton_lazy1(){};
    // 加锁
    public static synchronized Singleton_lazy1 getInstance(){
        // 如果实例未创建,则先创建该实例
        if(singleton == null){
            singleton = new Singleton_lazy1();
        }
        return singleton;
    }
}

2.4:懒汉模式-线程安全-同步代码块

优缺点:与同步方法的一样。

/**
 * 单例模式-懒汉模式
 * 线程安全-同步代码块延迟加载
 * @author live
 *
 */
public class Singleton_lazy2{
    private static Singleton_lazy2 singleton = null;
    private Singleton_lazy2(){};
    
    public static Singleton_lazy2 getInstance(){
        // 加锁
        synchronized (Singleton_lazy2.class) {
            // 如果实例未创建,则先创建该实例
            if(singleton == null){
                singleton = new Singleton_lazy2();
            }
        }
        return singleton;
    }
}

2.5:懒汉模式-线程安全-双重检查

优缺点:使用两次if判断进行检查,避免了每次判断都进入同步代码块的情况。实现了线程安全且效率高的优点。

/**
 * 单例模式-懒汉模式
 * 线程安全-双重检查
 * @author live
 *
 */
public class Singleton_lazy3{
    private static volatile Singleton_lazy3 singleton = null;
    private Singleton_lazy3(){};
    
    public static Singleton_lazy3 getInstance(){
        if(singleton == null){
            // 加锁
            synchronized (Singleton_lazy3.class) {
                // 如果实例未创建,则先创建该实例
                if(singleton == null){
                    singleton = new Singleton_lazy3();
                }
            }
        }
        return singleton;
    }
}


2.6:匿名内部类

优缺点:与饿汉模式类似,在类加载的时候创建实例,不同的是这种方法是在调用getInstance方法的是时候才会加载静态匿名内部类,实现了延迟加载,而且在静态属性第一次实例化的时候其他线程是无法参与。

public class Singleton_class{
    // 构造方法私有
    private Singleton_class(){};
    // 在内部类进行创建
    private static class Create_Singleton_class{
        private final static Singleton_class SINGLETON = new Singleton_class();
    }
    // 返回实例
    public static Singleton_class getInstance(){
        return Create_Singleton_class.SINGLETON;
    }
}


3.参考文章:

单例模式的八种写法比较
java单利模式

csdn发布地址
博客园发布地址

你可能感兴趣的