单例模式

单例模式就是始终只有一个实例对象的代码结构。
为了实现这种情况，就需要满足几个要求：

1. 私有化构造器，这样外部就无法直接创建对象
2. 声明一个静态成员变量，作为本类的唯一实例对象
3. 对外提供该静态成员变量

根据静态成员变量初始化位置的不同，单例模式可分为饿汉式和懒汉式

饿汉式：就是在类加载的时候就直接创建对象，无论是否需要

public class Singleton{
	/* 饿汉式
	 * 在类加载的时候就直接创建对象，无论是否需要
	 * public static保证在外部可以直接使用类名获取实例对象
	 *  final保证不会被修改
	 */
	public static final Singleton INSTANCE = new Singleton();
	//私有化构造器
	private Singleton(){}
}

在jdk5中添加的枚举类完全符合单例的要求，所以最简单的方式应该是这样的

public enum Singleton{
	//这就是唯一的对象实例，而枚举类构造器都是私有的
	INSTANCE
}

还有一种方式就是在静态代码块中创建对象，其实本质上并没有什么变化，只是有可能在创建对象之前还要进行其他一些操作，比如带参构造器需要提前读取配置文件中的信息来作为参数创建对象。

public class Singleton{
	public static final INSTANCE;
	private String name;
	static{
		Properties prop = new Properties();
		//读取配置文件中的信息用来创建对象
		prop.load(Singleton.class.getClassLoader().getResourceAsStream("info.properties"));
		INSTANCE = new Singleton(prop.getProperty("name"));
	}
	//私有化构造器
	private Singleton(String name){
		this.name = name;
	}
}

懒汉式：在需要的时候才创建对象返回

public class Singleton{
	//懒汉式：声明时并不创建，在外部调用公共的获取方法时才创建对象
	private static Singleton instance;
	//私有化构造器
	private Singleton(){}
	//公共的获取唯一对象的方法，在方法中才创建对象
	public static singleton getInstance(){
		//判断instance为空时，创建对象，否则直接返回该对象，保证实例对象唯一
		if(instance == null){//①
			instance = new Singelton();//②
		}
		return instance;
	}
}

这种方式其实只适用于单线程，当多线程时可能存在安全问题：一个线程a进入①还未执行②时，另一个线程b也进入①，那么最后线程a和b都会创建一个对象，这就不是单例了。
针对这种情况，可以使用同步代码块来保证线程安全

public class Singleton{
	//懒汉式：声明时并不创建，在外部调用公共的获取方法时才创建对象
	private static Singleton instance;
	//私有化构造器
	private Singleton(){}
	//公共的获取唯一对象的方法，在方法中才创建对象
	public static singleton getInstance(){
		//使用同步代码块，保证在线程a获得锁，进行判断和创建的过程中，其他线程不会干扰
		synchronized(Singleton.class){
			//判断instance为空时，创建对象，否则直接返回该对象，保证实例对象唯一
			if(instance == null){
				instance = new Singelton();
			}
		}
		return instance;
	}
}

这种方式就可以解决在多线程中的安全问题。
但是，效率略差！
在第一个线程a进入同步代码块，最终创建了对象之后，其他线程其实完全没有必要再进入同步代码块，毕竟同步代码块中一次只能进入一个线程，其他线程只能等待，白白浪费时间。所以还可以进行优化

public class Singleton{
	//懒汉式：声明时并不创建，在外部调用公共的获取方法时才创建对象
	private static Singleton instance;
	//私有化构造器
	private Singleton(){}
	//公共的获取唯一对象的方法，在方法中才创建对象
	public static singleton getInstance(){
		/* 先进行一次判断，这样即便线程a和b都进来，但是接下来获得锁的还是只有一个线程，
		 * 等它执行完创建了对象之后，虽然另一个线程也会再进入同步代码块一次，但是再后来的线程
		 * 直接通过最外层的判断就获取了对象而不会再进入同步代码块了，从而提高了效率
		 */
		if(instance == null){
			//使用同步代码块，保证在线程a获得锁，进行判断和创建的过程中，其他线程不会干扰
			synchronized(Singleton.class){
				//判断instance为空时，创建对象，否则直接返回该对象，保证实例对象唯一
				if(instance == null){
					instance = new Singelton();
				}
			}
		}
		return instance;
	}
}

还有一种思路就是使用静态内部类

public class Singleton{
	//私有化构造器
	private Singleton(){}
	// 静态内部类，不随外部类的加载而加载，而是在使用的时候才加载，而且只加载一次 
	private static class Inner{
		private static final Singleton INSTANCE = new Singleton();
	}
	//提供公共的获取方法
	public static Singleton getInstance(){
		return Inner.INSTANCE;
	}
}

所以这就是最简单的线程安全的懒汉式单例模式