Java单身狗 —— 单例模式

什么单例模式？

 

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

 

为什么要使用单例模式？

 

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

 

如何设计单例模式？

 

• 不允许其他程序new对象
• 在该类中创建对象
• 对外提供一个可以让其他程序获得该类对象的方法

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

• 私有化该类的构造方法
• 在本类中new一个对象
• 定义一个共有方法，将本类中的新建对象返回

 

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

 

1.饿汉模式

 

        这种方法缺点就是classloader机制避免了多线程问题的同时，也让类加载的时候instance就已经实例化。不管后续需不需要实例化对象，都已经创建了对象，占用内存。

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() {  
    }  
}

 

一般情况，不建议使用懒汉模式，推荐饿汉模式。有明确任务要求可以考虑其他。