设计思想学习—单例模式

单例模式

单例模式（singleton）： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式个人感觉是最简单的设计模式，因为他的目的很简单，并且没有用到太多的面对对象的特征，所以很简单。
单例模式主要是为了不要有重复的实例出现。
主要分为了两种：
懒汉

 public class Singleton {  
        private static Singleton instance;
        private Singleton() {} ;
        public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
        }  
    }  

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。 当时当多线程的时候难免会出现多个实例，所以线程不安全。

恶汉

    public class Singleton {  
        private static fianl Singleton instance = new Singleton();  
        private Singleton (){}  
        public static Singleton getInstance() {  
        return instance;  
        }  
    }  

恶汉在类创建的时候就已经实例化好一个静态的实例，而且不会被改变了，所以它天生就是线程安全。

针对懒汉的线程不安全的问题又出现了集中安全的懒汉：

• 在getInstance()方法上加锁

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

这种办法虽然成功的解决了线程问题，但是在方法上加锁每次都要都要同步，浪费很多性能。

• 双重检查锁定

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

同样的既然加锁就会同步，只不过比上面那种稍好一点因为锁的内容越少，消耗越小。

• 静态内部类

    public class Singleton {  
        private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
        }  
        private Singleton (){}  
        public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
        }  
    }  

这种方法和饿汉很相似，只不过不同的是，使用了内部类，所以在类创建的时候并不会创建实例，而是在调用的时候创建实例，这种方法算是融合懒汉和饿汉的有点，同时也不会有加锁的问题。

其实还有更好的就是使用1.5后更新的新特性，就是使用枚举，这种方式也是最提倡的。

public enum Singleton {  
    INSTANCE;  
}  

简单粗暴

---

至此五种创建型的设计模式已经全部学习完毕
分别是：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
下次将学习结构型设计模式。