zoukankan      html  css  js  c++  java
  • 枚举类型的单例模式(java)

    Inspired by Effective Java.

    Singleton模式是在编程实践中应用最广泛的几种设计模式之一。以前知道的,实现单例的方法有两种(下面的A、B)。刚刚在读《Effective Java的时候》学到一种新的更好的方法(E):单元素的枚举类型。同时通过网上资料也知道了其他两种方法(C、D)。最后一种在Java中从1.5版本开始支持,其他语言在验证后说明。

    A.饿汉式(类加载的时候就创建实例)。
    代码如下:

    public class MaYun {
        public static final Mayun instance = new Mayun(); //静态的final的MaYun
        private MaYun() {
            //MaYun诞生要做的事情
        }
        public void splitAlipay() {
            System.out.println(“Alipay是我的啦!看你丫Yahoo绿眉绿眼的望着。。。”);
        }
    }
    Call:MaYun.instance.splitAlipay();

    Feature:可以通过反射机制攻击;线程安全[多个类加载器除外]。

    A+.饿汉变种[推荐]

    public class MaYun {
        private static Mayun instance = new Mayun();
        private static getInstance() {
            return instance;
        }
        private MaYun() {
            //MaYun诞生要做的事情
        }
        public void splitAlipay() {
            System.out.println(“Alipay是我的啦!看你丫Yahoo绿眉绿眼的望着。。。”);
        }
    }

    A++.饿汉变种(类初始化的时候实例化instance):

    public class MaYun {
        private MaYun instance = null;
        static {
            instance = new MaYun();
        }
        private MaYun() {
            //MaYun诞生要做的事情
        }
        public static MaYun getInstance() {
            return this.instance;
        }
        public void splitAlipay() {
            System.out.println(“Alipay是我的啦!看你丫Yahoo绿眉绿眼的望着。。。”);
        }
    }

    B.懒汉式。
    代码如下:

    public class MaYun {
        private static MaYun instance = null;
        private MaYun() {
            //MaYun诞生要做的事情
        }
        public static MaYun getInstance() {
            if (instance == null) {
                instance = new MaYun();
            }
            return instance;
        }
        public void splitAlipay() {
            System.out.println(“Alipay是我的啦!看你丫Yahoo绿眉绿眼的望着。。。”);
        }
    }
    Call:MaYun.getInstance().splitAlipay();

    Feature:延时加载;线程不安全,多线程下不能正常工作;需要额外的工作(Serializable、transient、readResolve())来实现序列化。

    B+.懒汉式变种。

    public class MaYun {
        private static MaYun instance = null;
        private MaYun() {
            //MaYun诞生要做的事情
        }
        public static synchronized MaYun getInstance() {
            if (instance == null) {
                instance = new MaYun();
            }
            return instance;
        }
        public void splitAlipay() {
            System.out.println(“Alipay是我的啦!看你丫Yahoo绿眉绿眼的望着。。。”);
        }
    }

    Feature:线程安全;效率比较低,因为需要线程同步的时候比较少。

    C.静态内部类[推荐]。
    代码如下:

    public class MaYun {
        private static class SigletonHolder {
            private static final instance = new MaYun();
        }
        public static final getInstance() {
            return SigletonHolder.instance;
        }
        private MaYun() {
            //MaYun诞生要做的事情
        }
        public void splitAlipay() {
            System.out.println(“Alipay是我的啦!看你丫Yahoo绿眉绿眼的望着。。。”);
        }
    Call:MaYun.getInstance().splitAlipay();

    Feature:线程安全;延迟加载。

    D.双重校验锁[不推荐]。
    代码如下:

    public class MaYun {
        private volatile static MaYun instance;
        private MaYun (){}
        public static MaYun getInstance() {
            if (instance == null) {
                synchronized (MaYun.class) {
                    if (instance == null) {
                        instance = new MaYun();
                    }
                }
            }
            return instance;
        }
    }

    Feature:jdk1.5之后才能正常达到单例效果。

    E.编写一个包含单个元素的枚举类型[极推荐]。
    代码如下:

    public enum MaYun {
        himself; //定义一个枚举的元素,就代表MaYun的一个实例
        private String anotherField;
        MaYun() {
            //MaYun诞生要做的事情
            //这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候:
            /** himself = MaYun() {
                    * //MaYun诞生要做的事情
            * }
            **/
        }
        public void splitAlipay() {
            System.out.println(“Alipay是我的啦!看你丫Yahoo绿眉绿眼的望着。。。”);
        }
    }
    Call:MaYun.himself.splitAlipay();

    Feature:从Java1.5开始支持;无偿提供序列化机制,绝对防止多次实例化,即使在面对复杂的序列化或者反射攻击的时候。

    JDK 1.5引入枚举,通过枚举,我们也可以实现单例模式,不仅仅是单例哦,以下是稍微拓展之后的代码:

    public enum SingletonEnum
    {
        INSTANCE01,INSTANCE02;
        private String name;
        public String getName()
        {
             return name;
        }
         public void setName(String name)
        {
           this.name = name;
        }
     }

    测试

    public class Test
    {
        public static void main(String[] args)
        {
            SingletonEnum instance01=SingletonEnum.INSTANCE01;
            instance01.setName("terje");
            System.out.println(instance01.getName());
            
            SingletonEnum instance02=SingletonEnum.INSTANCE01;
            System.out.println(instance02.getName());
            
            SingletonEnum instance03=SingletonEnum.INSTANCE02;
            instance03.setName("liu");
            System.out.println(instance03.getName());
            
            SingletonEnum instance04=SingletonEnum.INSTANCE02;
            instance04.setName("liu");
            System.out.println(instance04.getName());
    
        }
    
    }

    输出:

    terje
    terje
    liu
    liu

    总之,五类:懒汉,恶汉,双重校验锁,静态内部类,枚举。
    恶汉:因为加载类的时候就创建实例,所以线程安全(多个ClassLoader存在时例外)。缺点是不能延时加载。
    懒汉:需要加锁才能实现多线程同步,但是效率会降低。优点是延时加载。
    双重校验锁:麻烦,在当前Java内存模型中不一定都管用,某些平台和编译器甚至是错误的,因为instance = new MaYun()这种代码在不同编译器上的行为和实现方式不可预知。
    静态内部类:延迟加载,减少内存开销。因为用到的时候才加载,避免了静态field在单例类加载时即进入到堆内存的permanent代而永远得不到回收的缺点(大多数垃圾回收算法是这样)。
    枚举:很好,不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。但是失去了类的一些特性,没有延迟加载,用的人也太少了~~

    以后多推广推广单元素枚举这种更好的单例实现方式。在项目中的代码开始修改实施

  • 相关阅读:
    Sublime 设置移动光标快捷键
    Reverse Linked List II
    Reverse Nodes in K-Group
    Sort Colors
    Swap Nodes in Pairs
    Intersection of Two Linked Lists
    Word Break
    Unique Binary Search Tree
    Maximal Square
    Happy Number
  • 原文地址:https://www.cnblogs.com/duanxz/p/3630125.html
Copyright © 2011-2022 走看看