设计模式之单例模式

     最近把设计模式看完了，之前已经把UML的内容写了一点，够看类图的水平，现在分别记录下各个设计模式。

  设计模式的定义

    保证一个类仅有一个实例，并提供一个访问它的全局访问点（好吧，我无耻的百度百科了...）

    

    单例模式分为懒汉式和饿汉式，饿汉式这种相对简单，就先来说说这种

    饿汉式单例模式

public class Singleton {
    private static final Singleton singleton = new Singleton();
    private Singleton() {
        System.out.println("Singleton 初始化");
    }

    public static Singleton getInstance() {
        System.out.println("获取实例");
        return singleton;
    }
    public static void main(String[] args) {
        Singleton s = Singleton.getInstance();
        System.out.println(s);
    }
}

   

public enum SingletonEnum {
    RED("123", "red"),
    GREEN("456", "green");

    @Setter
    @Getter
    private String code;

    @Setter
    @Getter
    private String name;

    // 构造方法
    private SingletonEnum(String name, String code) {
        System.out.println("初始化" + name + code);
        this.name = name;
        this.code = code;
    }

    // 普通方法
    public static String getName(String code) {
        for (SingletonEnum c : SingletonEnum.values()) {
            if (c.getCode().endsWith(code)) {
                return c.name;
            }
        }
        return null;
    }


    public static void main(String[] args) {
        System.out.println("开始");
        SingletonEnum red =  SingletonEnum.RED;
        System.out.println(red.getCode());
        System.out.println(red.getName(red.getCode()));
    }
}

 

   懒汉式单例模式

public class Singleton {
    private static  Singleton singleton = null;
    private Singleton() {
        System.out.println("Singleton 初始化");
    }

    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            System.out.println("获取实例 第一次");
            singleton = new Singleton();
            return singleton;
        }

        System.out.println("获取实例 非第一次");
        return singleton;
    }
    public static void main(String[] args) {
        Singleton s = Singleton.getInstance();
        Singleton s1 = Singleton.getInstance();
        System.out.println(s);
        System.out.println(s1);
        Assert.assertEquals(s,s1);
    }
}

   当然这里利用了对方法的同步，虽然避免了线程安全的问题，但是牺牲了效率，如果这个类非常常用，那很显然对系统的吞吐影响很大。对应的懒汉式也有几种其余的实现方式

  其一：双重加锁

public static Singleton getInsantace1() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                    return singleton;
                }
            }
        }
        return singleton;
    }

其中signleton需要用volatile修饰，这种方式很显然，代码的观赏性和可读性还是蛮差的，据说在JDK1.5之前也是有问题的，volatile还有一个重要的作用防止指令重排，对指令重排和volatile关键字感兴趣的可以移步 http://www.infoq.com/cn/articles/java-memory-model-2 和 http://www.infoq.com/cn/articles/java-memory-model-4。

  其二：静态内部类

private static  Singleton singleton = null;
    private Singleton() {
        System.out.println("Singleton 初始化");
    }

    public static Singleton getInstance2() {
        return SingletonHodler.singleton;
    }

    private static class SingletonHodler {
        private static Singleton singleton = new Singleton();
    }

单例大概就是这个样子，这里说的不细，全当自己的笔记，推荐研磨设计模式这本书，在设计模式当中还是不错的，当然博客园也有很多大神的博客可以参考。

 

  参考：研磨设计模式