单例模式的java实现

最新推荐文章于 2023-03-22 11:22:49 发布

weixin_33763244

最新推荐文章于 2023-03-22 11:22:49 发布

阅读量65

点赞数

文章标签： java python

原文链接：https://my.oschina.net/building/blog/95481

版权

2019独角兽企业重金招聘Python工程师标准>>>

前段时间买了几本java相关的书,每天晚上回去看一两个小时,感受颇深.因此写几篇随笔,作为读书笔记,加深下个人理解,顺便与大家分享下.因为水平有限,文章中可能难免有不当之处,希望各位多多指出,小弟在此谢过.
单例模式(singleton)顾名思义，就是只有一个实例。

作为对象的创建模式， 单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

在java语言中，单例模式的两大好处：

1、对于频繁使用的对象，使用单例模式，可以减少创建对象所花费的时间，对于那些重量级对象而言，是非常可观的系统开销。

2、由于new的操作次数减少，因此可以降低对内存的使用频率，减轻GC压力，缩短GC停顿时间。

单例模式的三个要点:
一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
一、首先我们来实现一个简单的单例。

1)为了确保一个类只有一个实例，所以我们这里要把类的构造方法使用private修饰。(注：使用private修饰构造方法也不能确保该类不会在其他地方被初始化，使用反射可以做到，但是反射式特殊情况，这里不予考虑。 :) .)

2)类必须有一个static方法可以产生实例。

/**
 * 简单的单例模式实现
 * @author shine
 */
public class MySingleton {
	private MySingleton(){	//使用private修饰，避免在其他地方被实例化
		System.out.println("create MySingleton class");
	}
	private static MySingleton singleton=new MySingleton();
	public static MySingleton getInstance(){//static方法，提供自身实例
		return singleton;
	}
}

测试代码

public class MainTest {
	public static void main(String[] args) {
		MySingleton mySingleton=MySingleton.getInstance();
	}
}

控制台输出：create MySingleton class

到现在，我们已经自己实现了一个单例模式，这种单例模式很简单，而且很可靠。

但是假如我们遇到了这种情况：你只想调用该类的一个静态方法，并不想拿到该类的实例，会发生什么情况？

/**
 * 简单的单例模式实现
 * 
 * @author shine
 */
public class MySingleton {
	private MySingleton() { // 使用private修饰，避免在其他地方被实例化
		System.out.println("create MySingleton class");
	}

	private static MySingleton instance= new MySingleton();

	public static MySingleton getInstance() {// static方法，提供自身实例
		return instance;
	}

	public static void doSomeThing() { //模拟单例类扮演其他角色
		System.out.println("now is" + new Date());
	}
}

假如我们的MySingleton类在系统中还扮演其他角色，比如说输出当前时间等等。那么在我们调用这些方法的时候，我们的类实例就会被创建出来。因为我们的instance成员变量是被static修饰的，所以在JVM加载我们的单例类的时候，单例对象就会被建立出来。也就是说，在任何使用单例类的的地方都会初始化我们的单例变量，而无论我们是否需要一个实例。

测试如下

public class MainTest {
	public static void main(String[] args) {
		MySingleton.doSomeThing();	//我们只需调用方法，不需要实例
	}
}

控制台输出如下：

create MySingleton class
now isWed Dec 12 22:32:03 CST 2012

如果我们的单例类比较重量级，那么同样在这里也是一笔多余的性能开销。

二、为了解决这个问题，我们需要实现延迟加载机制.

/**
 * 单例模式（懒加载机制）
 * 
 * @author shine
 * 
 */
public class LazySingleton {
	private LazySingleton() {
		System.out.println("create LazySingleton class");
	}

	private static LazySingleton instance = null;

	public synchronized static LazySingleton getInstance() {
		if (instance == null) {
			instance = new LazySingleton();
		}
		return instance;
	}

	public static void doSomeThing() {// 模拟单例类扮演其他角色
		System.out.println("now is" + new Date());
	}
}

首先对于我们的静态成员变量（也就是我们的实例）初始值赋予null.确保系统启动该类被加载的时候没有额外的负担。然后在我们的工厂方法getInstatnce()中，首先判断单例是否已经存在，如果存在则直接返回，否则就创建一个新的实例。

这里需要注意的是，getInstatnce()必须是同步的，因为在多线程环境下，当线程1正在新建单例时，完成赋值操作前。线程2可能正好判断instance为null，也去执行创建实例的操作，有可能导致多个实例被创建。所以同步关键字是必须的。

测试如下

public class MainTest {
	public static void main(String[] args) {
		System.out.println("test MySingleton doSomeThing");
		MySingleton.doSomeThing();	//我们只需调用方法，不需要实例
		System.out.println("test LazySingleton doSomeThing");
		LazySingleton.doSomeThing();//我们只需调用方法，不需要实例
	}
}

控制台输出：

test MySingleton doSomeThing
create MySingleton class
now isWed Dec 12 22:49:54 CST 2012
test LazySingleton doSomeThing
now isWed Dec 12 22:49:54 CST 2012

通过这种方式，我们虽然实现了延迟加载的功能，但是和第一种方式比，它引入了同步关键字，所以多线程环境中，它的时间消耗要远远大于第一种单例模式。为了延迟加载反而降低了系统性能，是不是有点得不偿失呢？我们再对其进行改造：

三、无需同步的延迟加载，提高性能

/**
 * 单例模式，使用内部类实现的延迟加载
 * @author shine
 *
 */
public class StaticSingleton {
	private StaticSingleton() {
		System.out.println("create StaticSingleton class");
	}

	public static class SingletonHolder {
		private static StaticSingleton instance = new StaticSingleton();
	}

	public static StaticSingleton getInstance() {
		return SingletonHolder.instance;
	}
}

在这段代码中，通过内部类实现单例类的延迟加载。当StaticSingleton被加载的时候，它的内部类不会被初始化，只有在调用getInstance()方法的时候，才会加载内部类，从而初始化instance实例。

因为实例的建立是在类加载的时候完成，所以天生对多线程友好。因此，这种方式兼备以上两种方式的优点。

注：本文部分内容来自《java程序性能优化》一书。转载请注明出处。

以后会持续发表相关的读书笔记，请关注。:) 谢谢。

转载于:https://my.oschina.net/building/blog/95481