Java设计模式笔记(单例模式）

**单例模式：**采用一定的方法在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供只提供一个获得其对象的方法。

单例模式的几种实现模式：
1）饿汉式（静态常量）
2）饿汉式（静态代码快）
3）懒汉式（线程不安全）
4）懒汉式（线程安全，同步方法）
5）懒汉式（线程安全，同步代码块）
6）双重检查
7）静态内部类
8）枚举

饿汉式与懒汉式：
饿汉式：在类加载的时候就创建实例
懒汉式：需要用到实例时再创建实例

1）饿汉式（静态常量）
优点：在类装载的时候就完成了实例化，避免了线程同步的问题
缺点：在类装载的时候就完成实例化，没有达到Lazyloading的效果，如果始终没有用过这个实例，就会造成内存的浪费。

//测试代码
public class Single01 {
    public static void main(String[] args) {
        Singleton instance=Singleton.getInstance();
        Singleton instance2=Singleton.getInstance();
        System.out.println(instance==instance2);
        System.out.println("instance="+instance.hashCode());
        System.out.println("instance2="+instance.hashCode());
    }
}
//饿汉式，静态常量
class Singleton{
    //构造器私有化，外部不能new
    private Singleton(){
    }
    //本类内部创建对象实例
    private final static Singleton instance=new Singleton();

    //提供一个公有的静态方法获得实例
    public static Singleton getInstance(){
        return instance;
    }
}

2）饿汉式（静态代码块）
以静态代码块的方式实例化对象，与1的优缺点相同

//饿汉式，静态代码块
class Singleton{
    //构造器私有化，外部不能new
    private Singleton(){
    }
    //本类内部创建对象实例
    private final static Singleton instance;
    static{
        instance=new Singleton();
    }
    //提供一个公有的静态方法获得实例
    public static Singleton getInstance(){
        return instance;
    }
}

3）懒汉式（线程不安全）
优点：在需要使用实例时在完成实例化，不会造成内存浪费，但是只能在单线程下使用。
缺点：线程不安全。一个线程在进入if(instance==null)判断代码块，还没来得及创建实例时，其他线程也有可能进入这个判断语句，这样就有可能产生多个实例。

//懒汉式,线程不安全
class Singleton{
    //构造器私有化，外部不能new
    private Singleton(){
    }
    //本类内部创建对象实例
    private  static Singleton instance;
    
    //提供一个公有的静态方法获得实例
    public static Singleton getInstance(){
        if(instance==null){
           instance=new Singleton();
        }
        return instance;
    }
}

4）懒汉式（线程安全，同步方法）
使用synchronized同步获得实例的静态方法
优点：解决了线程安全的问题
缺点：效率太低，每个线程在获得实例执行getInstance方法时都要进行同步，而其实这个方法只需要实例化一次就够了。

//懒汉式，线程安全
class Singleton{
    //构造器私有化，外部不能new
    private Singleton(){
    }
    //本类内部创建对象实例
    private  static Singleton instance;

    //提供一个公有的静态方法获得实例，并加入同步处理的代码
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

5）懒汉式（同步代码块）
没有实际意义，实际上多个线程还是有机会同时进入判断语句，创建多个实例。

//懒汉式，线程安全
class Singleton{
    //构造器私有化，外部不能new
    private Singleton(){
    }
    //本类内部创建对象实例
    private  static Singleton instance;

    //提供一个公有的静态方法获得实例，并加入同步处理的代码
    public static  Singleton getInstance(){
        if(instance==null){
            synchronized (Singleton.class){
            instance=new Singleton();
            }
        }
        return instance;
    }
}

6）双重检查
优点：延迟加载、效率较高，建议使用这种方法

class Singleton{
    //构造器私有化，外部不能new
    private Singleton(){
    }
    //本类内部创建对象实例
    private  static volatile Singleton instance;

    //提供一个公有的静态方法获得实例
    public static Singleton getInstance(){
        if(instance==null){
            synchronized (Singleton.class){
                if(instance==null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

7）静态内部类
1）这种方法采用了类装载的机制，保证了只能有一个线程能创建实例
2）在Singleton装载时，静态内部类SingletonInstance不会被装载，只有在执行getInstance方法时，才会装载SingletonInstance，保证了延迟加载。

优点：线程安全，利用静态内部类的特点实现延迟加载，效率高

class Singleton{
    //构造器私有化，外部不能new
    private Singleton(){
    }
    //写一个静态内部类，该类有一个静态属性Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE=new Singleton();
    }
    //提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE;
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

8）枚举
避免多线程同步问题，还能防止反序列化创建新的对象

public class Singel08 {
    public static void main(String[] args) {
        Singleton instance= Singleton.Instance;
        Singleton instance2= Singleton.Instance;
        System.out.println(instance==instance2);
        System.out.println("instance="+instance.hashCode());
        System.out.println("instance2="+instance.hashCode());
    }
}

enum Singleton{
    Instance;
}