1.饿汉式（不支持并发）
此模式只能运行在单线程下，且类在加载时就已经创建好了实例，不管需不需要用。
package com.lys;
//饿汉式
public class Singleton1 {
private Singleton1() {
}
private static Singleton1 instance = new Singleton1();
public static Singleton1 getInstance(){
return instance;
}
}2.懒汉式(不支持并发)
此模式只能运行在单线程下，在调用获取实例的方法时才创建实例。
package com.lys;
//懒汉式、不支持多并发
public class Singleton2 {
private Singleton2() {
}
private static Singleton2 instance = null;
public static Singleton2 getInstance(){
if (instance == null){
instance = new Singleton2();
}
return instance;
}
}3.懒汉式(支持并发、synchronized)
synchronized 锁住了整个方法，当有多个线程需要访问方法时，不管实例有没有创建，都会要排队等待才能拿到实例，效率低。
需要改进：只有第一次创建实例时才需要锁，其他时候不需要加锁。
package com.lys;
//懒汉式、支持多并发、效率低
public class Singleton3 {
private Singleton3() {
}
private static Singleton3 instance = null;
public synchronized static Singleton3 getInstance(){
if (instance == null){
instance = new Singleton3();
}
return instance;
}
}4.双重检查锁 (volatile)--常用
volatile 关键字保证了内存可见性，所有线程都会去主存中取数据而不是在线程的缓存中取，保证了数据的更新能实时地对任何线程可见。
假如有两个线程同时到达了1，它们都去创建实例，这时候如果没有第二次判断，就会多次创建实例了。二次判断保证了多线程下只创建一个实例。
package com.lys;
//double checked locking、支持多并发、效率高、添加volatile关键字
public class Singleton4 {
private Singleton4() {
}
private volatile static Singleton4 instance = null;
public static Singleton4 getInstance(){
if (instance == null){//1
synchronized (Singleton4.class) {
if (instance == null)//2
instance = new Singleton4();
}
}
return instance;
}
}5.静态私有内部类（最常用）
内部类的好处：内部类在被调用的时候才实例化其静态成员变量，高！
package com.lys;
//静态私有内部类、支持多并发、效率高、
public class Singleton5 {
private Singleton5() {
}
private static class SingletonHolder{
private static Singleton5 instance = new Singleton5();
}
public static Singleton5 getInstance(){
return SingletonHolder.instance;
}
}