设计模式-单列模式-其他的几种方式

静态代码块

/**
 * 单列模式
 * 饿汉模式-静态代码块的实现
 *
 *  优点：没有加锁，执行效率会提高。它基于classloder机制避免了多线程的同步问题
 *  缺点：类加载时就初始化，没有达到lazy loading的效果，浪费内存。
 */
public class SingletonStaticDemo {
        private static SingletonStaticDemo singleton;
        //在静态代码块执行时，创建单例对象
        static {
            singleton=new SingletonStaticDemo();
        }
        private  SingletonStaticDemo(){
        }
        public static SingletonStaticDemo getInstance(){
            return singleton;
        }
}

静态变量（饿汉的方式）

/**
 * 饿汉式的静态变量的方式
 * 可能造成内存浪费
 *
 */
public class SingletonDemo02 {
    public static void main(String[] args) {
        Singleton2 singleton=Singleton2.getInstance();
        Singleton2 singleton1=Singleton2.getInstance();
        System.out.println(singleton==singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton2{
    //1、构造器私有化，防止外部通过new来创建对象
    private Singleton2(){}
    //2、本类内部创建对象实例
    private static Singleton2 instance;
    //3、在静态代码块中，创建单列对象
    static {
        instance=new Singleton2();
    }
    //4、提供一个公有的静态方法，返回实例对象
    public static Singleton2 getInstance(){
        return instance;
    }

}

线程不安全

/**
 * 单例模式-懒汉式
 * 线程不安全的
 *
 *
 */
public class SingletonDemo03 {
    public static void main(String[] args) {
        Singleton03 singleton=Singleton03.getSingleton03();
        Singleton03 singleton1=Singleton03.getSingleton03();
        System.out.println(singleton==singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}
class Singleton03{
    private  static Singleton03 singleton03;
    private Singleton03(){}
    public static Singleton03 getSingleton03(){
        if(singleton03==null){
            singleton03=new Singleton03();
        }
        return singleton03;
    }
}

双重检查

/**
 * 单例模式-双重检查
 * 保证了线程安全
 * 延迟加载，效率较高
 *
 */
public class SingletonDemo05 {
    public static void main(String[] args) {
        Singleton05 singleton=Singleton05.getSingleton05();
        Singleton05 singleton1=Singleton05.getSingleton05();
        System.out.println(singleton==singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton05{
    private  static volatile Singleton05 singleton05;
    private Singleton05(){}
    public static  Singleton05 getSingleton05(){
        if(singleton05==null){
            synchronized(Singleton05.class){
                if(singleton05==null) {
                    singleton05 = new Singleton05();
                }
            }

        }
        return singleton05;
    }
}

静态内部类

/**
 * 单例模式-静态内部类
 * 1)采用了类装载的机制保证初始化实例时只有一个线程
 * 2）静态内部诶方式在singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getinstance方法
 * 才会装载singletonstance类，从而完成singleton的实例化
 * 3）类的静态属性只会在第一次加载类的时候初始化，所以在这里，jvm帮助我们保证了线程的安全性，在类进行初始化时，别的线程无法进入的
 * 4）避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
 *
 */
public class SingletionDemo06 {
    public static void main(String[] args) {
        Singleton06 singleton=Singleton06.getSingleton06();
        Singleton06 singleton1=Singleton06.getSingleton06();
        System.out.println(singleton==singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton06{
    private  static  Singleton06 singleton06;
    //构造器私有化
    private Singleton06(){}
    //静态内部类，该类中有一个静态属性singleton
    private static class SingletonInstance{
        private  static final Singleton06 INSTANCE=new Singleton06();
    }
    //提供一个静态的公有方法，直接返回singletonInstance.INSTANCE
    public static Singleton06 getSingleton06(){
        return SingletonInstance.INSTANCE;
    }
}

枚举方式

/**
* 枚举方式
**/
public class SingletonDemo07 {
    public static void main(String[] args) {
        Singleton07 singleton=Singleton07.INSTANCE;
        Singleton07 singleton1=Singleton07.INSTANCE;

        System.out.println(singleton==singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
        singleton.sayOk();

    }
}

enum Singleton07{
    INSTANCE;
    public void sayOk(){
        System.out.println("======ok");
    }
}