Java —— 单例模式

什么单例模式？

单例模式是Java最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时保证只有单个对象被创建。这个类提供了一种访问其对象的唯一的方式（静态调用），可以直接调用，不需要实例化对象。

为什么要使用单例模式？

单例模式主要是为了避免创建多个实例而造成资源的浪费。它可以保证一个类的内存中对象的唯一性，在一些常用工具类、线程池、数据库、电脑打开任务管理器、控制面板等可能只允许我们创建一个对象，一方面如果创建多个对象可能引起程序错误，另一方面创建多个对象也会造成资源的浪费。

如何设计单例模式？

1. 不允许其他程序new对象

2. 在该类中创建对象

3. 对外提供一个可以让其他程序获得该类对象的方法

   （以上主要都是为了保证对象的唯一性。那么如何转化成代码呢?）

4. 私有化该类的构造方法

5. 在本类中new一个对象

6. 定义一个共有方法，将本类中的新建对象返回

常用单例模式的实现方法：

1.饿汉模式

public class EagerSingle {
	//自己创建对象(私有的静态变量,因为被静态方法调用)
	private static EagerSingle instance = new EagerSingle();
	
	 构造方法私有化(外界不能创建对象)
	 private EagerSingle() {
	 
	 }
	 /*
	  开放一个方法  能让外界拿到对象
     外界不可能  创建出对象来调用这个方法
     所以使用静态方法
	 */
	public static EagerSingle getInstance() {
		return instance;
	}
}

通过测试类代码了解实例情况：

public class Test {
 
	public static void main(String[] args) {
 
		EagerSingle es1 = EagerSingle.getInstance();
		System.out.println("es1: "+es1);
 
		es1 = null;
		System.out.println("es1: "+es1);
 
		EagerSingle es2 = EagerSingle.getInstance();
		System.out.println("es2: "+es2);
		
	}
 
}

很明显看到， 调用了两次getinstance()方法获得的是同一个对象的地址值。若对对象进行null赋值操作，也只是清除了其所存的地址的值，并不会对单例类的实例对象有任何影响。

2.懒汉模式

//不完整的懒汉式单例(出现线程问题)
public class LazySingle {
 //声明一个本类对象的引用( 与饿汉式单例不同的地方 )
	private static LazySingle instance = null;
	//私有化构造方法
	private LazySingle() {
	}
	//开放访问方法
	public static LazySingle getInstance() {
	 判断	
		if(instance == null)
			instance = new LazySingle();
		return instance;
	}
}

此时的懒汉模式并不支持多线程。若由多线程并行操作，因为对象的创建也需要一定的时间开销，上一个线程对象还未创建完成时地址值为null，下一个线程说不定也要创建对象。显然instance会指向最后创建的对象。

   给方法加上同步锁synchronized就ok啦。

public static synchronized LazySingle getinstance(){}

3.双重校验锁 / 双检锁

public class DoubleCheckedSingle {
	
	private static DoubleCheckedSingle instance = null;
	
	private DoubleCheckedSingle() {};
	
	public static DoubleCheckedSingle getInstance() {
 
		if(instance == null) {
			synchronized (DoubleCheckedSingle.class) {
				if(instance == null) {
					instance = new DoubleCheckedSingle();
				}
			}
		}
		return instance;
	}
}

加了同步锁以后会影响程序运行的效率，这里可以采用双锁机制，安全且在多线程的情况下保持高性能。

4.静态内部类

同样利用了classloader机制保证初始化instance只有一个线程，和饿汉模式不同的是：饿汉模式只要类加载就会实例化对象，而这种方式的StaticSingle类即使被加载了也不一定产生实例化对象，因为静态内部类没有被调用，只有调用了StaticSingleHolder才会实例化instance对象。
也就是说，如果实例化instance很消耗资源，所以想要延迟加载，另一方面又不希望instance被加载时就实例化，而是需要时采取主动调用方法实例化，也是线程安全，这种静态内部类就很合适。

public class StaticSingle {
 
	private static class StaticSingleHolder{
		private static final StaticSingle instance = new StaticSingle();
	}
	
	private StaticSingle() {}
	
	public static StaticSingle getInstance() {
		return StaticSingleHolder.instance;
	}
}

5.枚举

这种实现方法还没有被广泛应用，但这却是最佳实现单例模式的方法。它简洁，绝对防止多次实例化，避免了线程同步，还自动支持序列化机制。不过由于是JDK1.5以后加入的机制，很少用。所以不是很懂

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

一般情况，不建议使用懒汉模式，推荐饿汉模式。有明确任务要求可以考虑其他。对java感兴趣的朋友可以一起交流交流，裙947405150