确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例，从而减少内存开支，特别是一个对象需要被频繁的创建和销毁时。
第一种形式：懒汉式，也是常用的形式。
public class SingletonClass{
private static SingletonClass instance=null;
public static synchronized SingletonClass getInstance(){
if(instance==null){
instance=new SingletonClass();
}
return instance;
}
private SingletonClass(){
}
}
第二种形式：饿汉式
因为单例是静态的final变量，所以当类第一次加载到内存中的时候就初始化了，那么创建的实例固然是线程安全的。
public class Singleton{
// initailzed during class loading
private static final Singleton instance = new Singleton();
//to prevent creating another instance of Singleton
private Singleton(){
//do something
}
public static Singleton getInstance(){
return instance;
}
}
第三种形式：双重锁的形式
双重锁形式将同步内容下放到if内部，提高了执行的效率，这样就不必每次获取对象时都进行同步。 双重锁形式中双重判断加同步的方式，比第一个种懒汉式的效率大大提升
public class Singleton{
private static volatile Singleton instance=null;
private Singleton(){
//do something
}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
}
第四种方式：静态内部类方式
当外部类Singleton被加载时，其静态内部类SingeletonHolder不会被加载，所以它的成员变量sInstance是不会被初始化的，只有当调用Singleton.getInstance()方法时，才会加载SingeletonHolder并且初始化其成员变量，而类加载时是线程安全的，这样既保证了延迟加载，也保证了线程安全
public class Singleton {
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.sInstance;
}
private static class SingletonHolder {
private static Singleton sInstance = new Singleton();
}
}
第五种方式：静态工厂方式(通过反射创建单例)
通过反射生成对象，然后提供给外部访问，保证内存中的对象唯一。
public class SingletonFactory {
private static Singleton singleton;
static{
try{
Class cls = Class.forName(Singleton.class.getName());
Constructor constructor = cls.getDeclaredConstructor();
constructor.setAccessible(true);
singleton = (Singleton)constructor.newInstance();
}catch(Exception e){
// do something...
}
}
public static Singleton getSingleton(){
return singleton;
}
}
第六种方式：枚举方式
（缺陷-反射产生多个实例）饿汉式、懒汉式、静态内部类、双重校验锁的写法通过反射还是可以创建出多个实例：
private static void reflexCreate() {
try {
Singleton s1 = Singleton.getInstance();
Class<Singleton> cls = Singleton.class;
Constructor<Singleton> constructor = cls.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton s2 = constructor.newInstance(new Object[] {});
} catch (Exception e) {
e.printStackTrace();
}
}
（缺陷-序列化产生多个实例）饿汉式、懒汉式、静态内部类、双重校验锁的写法通过序列化还是可以创建出多个实例：
class Singleton implements Serializable {
private static Singleton instence = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instence;
}
}
private static void testSingleton() {
File file = new File("singleton");
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
oos = new ObjectOutputStream(new FileOutputStream(file));
Singleton Singleton1 = Singleton.getInstance();
oos.writeObject(Singleton1);
oos.close();
ois = new ObjectInputStream(new FileInputStream(file));
Singleton Singleton2 = (Singleton) ois.readObject();
System.out.println(Singleton1 == Singleton2);//false
} catch (FileNotFoundException | ClassNotFoundException | IOException e) {
e.printStackTrace();
} finally {
if (oos != null) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
这个问题可以在类中添加readResolve()方法来避免，即：
class Singleton implements Serializable {
private static Singleton instence = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instence;
}
// 不添加该方法则会出现 反序列化时出现多个实例的问题
public Object readResolve() {
return instence;
}
}
使用单元素的枚举实现单例模式
public enum EnumSingleton {
INSTACE; // 定义一个枚举元素，代表 EnumSingleton 一个实例
/**
* 枚举中的构造方法只能写成 private 或是不写「不写默认就是 private」，所以枚举防止外部来实例化对象
*/
EnumSingleton(){
}
/**
* 一些额外的方法
*/
public void doSometing(){
// do something...
}
}
这种方法在功能上与公有域方法相近，但是它更加简洁，无偿提供了序列化机制，绝对防止多次实例化，即使是在面对复杂序列化或者反射攻击的时候。虽然这种方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。
