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

我就是我 2023-02-15 10:04 18阅读 0赞

## 静态代码块 ##

/** * 单列模式 * 饿汉模式-静态代码块的实现 * * 优点：没有加锁，执行效率会提高。它基于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");
        }
    }