Java设计模式--单例模式

1. 单例模式的引入

class Singleton{
	public void print() {
		System.out.println("单例模式");
	}
}

我们都知道，默认情况下如果不写构造方法，Singleton类中也会存在无参的构造方法，而且是public的。如果使用private声明构造方法，会有什么神奇的事情发生呢？

class Singleton{
	private Singleton() {}  //构造方法私有了
	public void print() {
		System.out.println("单例模式");
	}
}

哈哈哈很神奇，现在我们将无法在外部调用构造方法，也就是此时的代码无法在外部进行实例化，也就是说我们写了一个这样的阳台。

那这么做才能让我们写的类能让外部访问呢？

分析一：private只能在本类中被调用，那么能不能在本类中准备好一个实例化对象呢？

class Singleton{
	Singleton instance= new Singleton();//instance有了
	private Singleton() {}  //构造方法私有了
	public void print() {
		System.out.println("单例模式");
	}
}

 

分析二：此时声明的instance属性是普通属性，普通属性是需要在类实例化之后才能使用的，但此时外部无法实例化对象，于是考虑用static，因为static声明的变量和方法存储在静态区，不受到实例化对象控制。

public class TestSingleton {
	public static void main(String[] args) {
		Singleton singleton = null;
		singleton = Singleton.instance;
		singleton.print();
	}
}

class Singleton{
	static Singleton instance = new Singleton();//instance变成static的了
	private Singleton() {}  //构造方法私有了
	public void print() {
		System.out.println("单例模式");
	}
}

分析三：规范的代码中，类中的属性就应该用private封装，那么instance属性也应当使用private封装，然后通过get方法去访问，于是编写一个static方法

public class TestSingleton {
	public static void main(String[] args) {
		Singleton singleton = null;
		singleton = Singleton.getSingleton();
		singleton.print();
	}
}

class Singleton{
	private static Singleton instance = new Singleton();//instance封装了
	private Singleton() {}  //构造方法私有了
	public void print() {
		System.out.println("单例模式");
	}
	public static Singleton getSingleton() {
		return instance;	
	}
}

分析四：为了保证实例的唯一性，那么久可以直接定义为final

public class TestSingleton {
	public static void main(String[] args) {
		Singleton singleton = null;
		singleton = Singleton.getSingleton();
		singleton.print();
	}
}
class Singleton{
	private static final Singleton INSTANCE = new Singleton();//instance变成一个常量了
	private Singleton() {}  //构造方法私有了
	public void print() {
		System.out.println("单例模式");
	}
	public static Singleton getSingleton() {
		return INSTANCE;
	}
}

惊喜不惊喜？意外不意外？我们就这样不知不觉竟然写了一个单例模式！

2. 单例模式的特点：

单例模式的源头是构造方法私有化。所以外部无法产生新的实例化对象，只能通过类提供的static方法获取类的唯一实例对象的引用。

3. 单例模式的两类：饿汉式和懒汉式

--饿汉式：无论有没有调用都进行实例化，上面的代码就是饿汉式单例的实现

  --懒汉式：在第一次使用的时候才进行实例化，下面是懒汉式单例的实现

public class TestSingleton {
	public static void main(String[] args) {
		Singleton singleton = null;
		singleton = Singleton.getSingleton();
		singleton.print();
	}
}

class Singleton{
	private static Singleton instance;
	private Singleton() {}  //构造方法私有了
	public void print() {
		System.out.println("单例模式");
	}
	public static  Singleton getSingleton() { //多线程情况下加synchronized
		if(instance==null) {
			instance = new Singleton();  //需要的时候才进行实例化
		}
		return instance;
	}
}

4. 拓展：双重加锁机制和类级内部类

4.1 双重加锁机制（多线程情况下）

多线程懒汉模式每一次执行时都要进行同步和判断，无疑会拖慢速度，使用双重加锁机制正好可以解决这个问题：

class SLHanSingleCase{
	private static volatile SLHanSingleCase singleCase = null;
	private SLHanSingleCase(){}
	public static SLHanSingleCase getInstance(){
		if( singleCase == null ){
			synchronized (SLHanSingleCase.class){
				if( singleCase == null ){
					singleCase = new SLHanSingleCase();
				}
			}
		}
		return singleCase;
	}
}

双重加锁难道不是需要两个synchronized进行加锁的吗？

• 第一重判断，如果单例已经存在，那么就不再需要进行同步操作，而是直接返回这个实例;如果没有创建，才会进入同步块，同步块的目的与之前相同，目的是为了防止有两个调用同时进行时，导致生成多个实例
• 第二个重空判断的作用，当多个线程一起到达锁位置时，进行锁竞争，其中一个线程获取锁，如果是第一次进入则dl为null，会进行单例对象的创建，完成后释放锁，其他线程获取锁后就会被空判断拦截，直接返回已创建的单例对象。

  不论如何，使用了双重加锁机制后，程序的执行速度有了显著提升，不必每次都同步加锁。

4.2  类级内部类的方式

* 饿汉式会占用较多的空间，因为其在类加载时就会完成实例化；

* 懒汉式又存在执行速率慢的情况；

* 双重加锁机制有执行效率差的毛病

有没有一种完美的方式可以规避这些毛病呢？貌似有的，就是使用类级内部类结合多线程默认同步锁（其实就是静态内部类），同时实现延迟加载和线程安全，不妨试试内机内部类。

class ClassInnerClassSingleCase{
	public static class SingleCaseHolder{
		private static ClassInnerClassSingleCase singleCase = new ClassInnerClassSingleCase();
	}
	private ClassInnerClassSingleCase(){}
	public static ClassInnerClassSingleCase getInstance(){
		return SingleCaseHolder.singleCase;
	}
}

5. 单例模式的使用场景

• Windows任务管理器、回收站
• 网站的计数器，一般也是采用单例模式实现，否则难以同步。
• 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。
• 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。