单例模式（创建型）

单例模式可以分为懒汉式和饿汉式
懒汉式：创建对象实例的时候不着急，等到使用对象实力的时候才会创建

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

饿汉式：饿了，着急创建对象实例

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

利用缓存来实现单例模式：

public class Singleton2 {
private static String instanceName = "one";
private static Map<String, Singleton2> map = new HashMap<String, Singleton2>();
private Singleton2() {}
public static Singleton2 getInstance(){
Singleton2 temp = (Singleton2)map.get(instanceName);
if(temp == null){
map.put(instanceName, new Singleton2());
return map.get(instanceName);
}
return temp;
}
}

单例模式的优缺点：
1.时间和空间：懒汉式是时间换空间，而饿汉式是空间换时间
2.线程安全：懒汉式线程不安全，饿汉式线程是安全的
懒汉式实现线程安全，需要加上synchronized：public static synchronized Singleton getInstance()但是会降低访问的速度.
双重检查加锁：实现了线程安全，对性能未造成太大伤害

public class Singleton4 {
private volatile static Singleton4 instance = null;
private Singleton4() {}
public static Singleton4 getInstance(){
//检查实例是否存在
if(instance == null){
synchronized(Singleton4.class){
if(instance == null){
instance = new Singleton4();
}
}
}
return instance;
}
}

Java中一种更好的单例实现方式：
前面两种方式均存在缺陷：延迟加载和线程安全。
因此大神采用静态内部类实现：因为静态内部类是在静态内部类被调用的时候加载所以达到的延迟加载的效果
这个模式的优势在于：getInstance方法并没有被同步，只是执行一个域的访问

public class Singleton5 {
private Singleton5() {}
private static class Singleton5instance{
private static Singleton5 instance = new Singleton5();
}
public static Singleton5 getInstance(){
return Singleton5instance.instance;
}
}