java单件模式

意图：确保一个类只有一个实例，并提供一个全局访问点
适用性：
1、当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时
2、当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时
结构图：

实例：

package com.test.patten.singleton;

public class Singleton {
    private static Singleton instance;
    private String message;

    private Singleton(){
        message ="message被初始化";
        System.out.println(System.currentTimeMillis());
    }
    
    public static Singleton getInstance() {
        if(instance == null){
            instance =  new Singleton();
        }
        return instance;
    }
    
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

package com.test.patten.singleton;

public class Client {
    public static void main(String args[]){
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.getMessage());
        
        //第二次获取
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton2.getMessage());
    }
}

输出：

1362036694546
message被初始化
message被初始化

从输出可以看出，第二次获取时，没有新建实例
考虑到并发，在getInstance()方法加上synchronized关键字修饰，但可能会使性能下降，可以有以下两种方式
1、使用'饿汉式'创建实例，而不用'懒汉式'的做法

package com.test.patten.singleton;

public class Singleton {
    private static Singleton instance = new Singleton();
    private String message;

    private Singleton(){
        message ="message被初始化";
        System.out.println(System.currentTimeMillis());
    }
    
    public static Singleton getInstance() {
        return instance;
    }
    
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

利用这个做法，依赖JVM在加载这个类时马上创建此唯一的单件实例，JVM保证在任何线程访问instance静态变量之前，一定先创建此实例
2、利用双重检查加锁，在getInstance()中减少使用同步，优化'懒汉式'初始化

package com.test.patten.singleton;

public class Singleton {
    private volatile static Singleton instance;
    private String message;

    private Singleton(){
        message ="message被初始化";
        System.out.println(System.currentTimeMillis());
    }
    
    public static Singleton getInstance() {
        if(instance == null){
            synchronized (Singleton.class) {
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

当关注性能时，这样的做法可以大大减少getInstance()耗费的时间
注意点：
1、单件模式需要一个私有的构造器、一个静态方法、一个静态变量
2、确定在性能和资源上的限制，然后小心的选择适当的方案以解决多线程的问题