23种设计模式（新手）-9单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）

饿汉式

1）构造器私有化

2）类的内部创建对象

3）向外暴露一个静态的公共方法

4）代码实现

优点：写法简单，在类转载就完成了实例化。避免了线程同步问题

缺点：在类装载的时候就完成了实例化，没有达到Lazy Loading的效果。如果从始至终从未用过这个实例，则会造成内存的浪费

java 复制代码

package src.design0Model1Danli.ehai1;

public class design7 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance==instance2);//true
    }
}
//饿汉式（静态变量）
class Singleton {
    //1.构造器私有化，外部能new
    private Singleton(){}
   //2.本部内部类创建对象实例
    public final static Singleton instance=new Singleton();
    //3.提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

静态代码块饿汉式

优缺点与上面相同

java 复制代码

public class design8 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance==instance2);//true
    }
}
//饿汉式（静态变量）
class Singleton {
    //1.构造器私有化，外部能new
    private Singleton(){}
    //2.本部内部类创建对象实例
    public static Singleton instance;
    static {//在静态代码块中创建单例对象
        instance =new Singleton();
    }
    //3.提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

懒汉式线程不安全

优点：起到懒加载的效果

缺点；多线程条件下不可使用

懒汉式线程安全，同步方法

解决线程安全问题

效率太低，

java 复制代码

public class design9 {
    public static void main(String[] args) {

    }
}

class Singleton{
    public static Singleton instance;
    private Singleton(){}
        //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
        //即懒汉式
    public static synchronized Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

懒汉式（线程安全，同步代码块）（线程不安全，无意义，不能使用）

双重检查

加入双重检查代码代码，解决线程安全问题，同时解决懒加载问题同时保证了效率，推荐

java 复制代码

public class design10 {
    public static void main(String[] args) {

    }
}

class Singleton{
    public static Singleton instance;
    private Singleton(){}
    //提供一个静态的公有方法，加入双重检查代码代码，解决线程安全问题，同时解决懒加载问题
    //同时保证了效率，推荐
    public static synchronized Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                if (instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类

采用类装载机制来保证初始化实例只有一个线程，类的静态属性在只会在第一次加载类的时候初始化，别的线程是无法进入的

避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

java 复制代码

public class design11 {
    public static void main(String[] args) {

    }
}

//静态内部类完成
class Singleton{
    public static Singleton instance;
    //构造器私有化
    private Singleton(){}
    //写一个静态内部类，该类中有一个静态属性Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }
    //提供一个静态的公有方法，直接返回成员变量
    public static synchronized Singleton getInstance(){
      return SingletonInstance.INSTANCE;
    }
}

枚举

借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

javascript 复制代码

public class design12 {
    public static void main(String[] args) {}
}
//使用枚举可以实现单例
enum Singleton{
    INSTANCE;
    public void sayOK(){
        System.out.println("Hello World");
    }
}

在jdk中java.lang.Runtime就是经典的单例模式饿汉式静态常量