一、懒汉模式,线程不安全
/**
* @author: yong_jiang@suishouji.com
* @create: 2018-10-16 11:16
* @desc: java单例写法一-懒汉模式,线程不安全
**/
public class SingletonLazy {
private static SingletonLazy instance;
private SingletonLazy(){
}
public static SingletonLazy getInstance(){
if(instance==null){
instance=new SingletonLazy();
}
return instance;
}
}
这种写法lazy loading很明显,但是致命的是在多线程不能正常工作。
二、懒汉模式,线程安全
/**
* @author: yong_jiang@suishouji.com
* @create: 2018-10-16 11:16
* @desc: java单例写法二-线程安全
**/
public class SingletonLazySynchronized {
private static SingletonLazySynchronized instance;
private SingletonLazySynchronized(){
}
public static synchronized SingletonLazySynchronized getInstance(){
if(instance==null){
instance=new SingletonLazySynchronized();
}
return instance;
}
}
这种写法能够在多线程中很好的工作,而且看起来它也具备很好的lazy loading,但是,遗憾的是,效率很低,99%情况下不需要同步。
三、饿汉模式
/**
* @author: yong_jiang@suishouji.com
* @create: 2018-10-16 13:38
* @desc: java单例写法三-饿汉模式
**/
public class SingletonHungry {
private static SingletonHungry instance=new SingletonHungry();
public SingletonHungry(){
}
public static SingletonHungry getInstance(){
return instance;
}
}
这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化,虽然导致类装载的原因有很多种,在单例模式中大多数都是调用getInstance方法, 但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance显然没有达到lazy loading的效果。
四、饿汉模式,通过静态代码块
/**
* @author: yong_jiang@suishouji.com
* @create: 2018-10-16 13:38
* @desc: java单例写法四-饿汉模式,通过静态代码块
**/
public class SingletonHungryStatic {
private static SingletonHungryStatic instance;
static{
instance=new SingletonHungryStatic();
}
public SingletonHungryStatic(){
}
public static SingletonHungryStatic getInstance(){
return instance;
}
}
表面上看起来差别挺大,其实更第三种方式差不多,都是在类初始化即实例化instance。
五、通过静态内部类实现单例
/**
* @author: yong_jiang@suishouji.com
* @create: 2018-10-16 13:57
* @desc: java单例写法五-静态内部类
**/
public class SingletonStaticInner {
private static class SingletonHandler{
private static final SingletonStaticInner INSTANCE=new SingletonStaticInner();
}
private SingletonStaticInner(){}
public static final SingletonStaticInner getInstance(){
return SingletonHandler.INSTANCE;
}
}
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程,它跟第三种和第四种方式不同的是(很细微的差别):第三种和第四种方式是只要Singleton类被装载了,那么instance就会被实例化(没有达到lazy loading效果),而这种方式是Singleton类被装载了,instance不一定被初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时,才会显示装载SingletonHolder类,从而实例化instance。想象一下,如果实例化instance很消耗资源,我想让他延迟加载,另外一方面,我不希望在Singleton类加载时就实例化,因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载,那么这个时候实例化instance显然是不合适的。这个时候,这种方式相比第三和第四种方式就显得很合理。
六、通过枚举实现单例
/**
* @author: yong_jiang@suishouji.com
* @create: 2018-10-16 14:44
* @desc: 通过枚举创建单例
**/
public enum SingletonEnum {
INSTANCE;
private Resouce resouce;
SingletonEnum(){
resouce=new Resouce();
}
public Resouce getInstance(){
return resouce;
}
}
class Resouce{
}
上面的类Resource是我们要应用单例模式的资源,具体可以表现为网络连接,数据库连接,线程池等等。
获取资源的方式很简单,只要 SomeThing.INSTANCE.getInstance() 即可获得所要实例。下面我们来看看单例是如何被保证的:
首先,在枚举中我们明确了构造方法限制为私有,在我们访问枚举实例时会执行构造方法,同时每个枚举实例都是static final类型的,也就表明只能被实例化一次。在调用构造方法时,我们的单例被实例化。
也就是说,因为enum中的实例被保证只会被实例化一次,所以我们的INSTANCE也被保证实例化一次。
可以看到,枚举实现单例还是比较简单的,除此之外我们再来看一下Enum这个类的声明:
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable
可以看到,枚举也提供了序列化机制。某些情况,比如我们要通过网络传输一个数据库连接的句柄,会提供很多帮助。
最后借用 《Effective Java》一书中的话:单元素的枚举类型已经成为实现Singleton的最佳方法。
七、双重校验锁实现单例
/**
* @author: yong_jiang@suishouji.com
* @create: 2018-10-16 14:52
* @desc: java单例写法七-双重校验锁实现单例-基于方法二
**/
public class SingletonLazyDoubleSynchronized {
private volatile static SingletonLazyDoubleSynchronized instace;
private SingletonLazyDoubleSynchronized(){}
private static SingletonLazyDoubleSynchronized getInstance(){
if(instace==null){
synchronized (SingletonLazyDoubleSynchronized.class){
if(instace==null){
instace=new SingletonLazyDoubleSynchronized();
}
}
}
return instace;
}
}
这个是第二种方式的升级版,俗称双重检查锁定,在JDK1.5之后,双重检查锁定才能够正常达到单例效果。
注意:
有两个问题需要注意:
1.如果单例由不同的类装载器装入,那便有可能存在多个单例类的实例。假定不是远端存取,例如一些servlet容器对每个servlet使用完全不同的类装载器,这样的话如果有两个servlet访问一个单例类,它们就都会有各自的实例。
2.如果Singleton实现了java.io.Serializable接口,那么这个类的实例就可能被序列化和复原。不管怎样,如果你序列化一个单例类的对象,接下来复原多个那个对象,那你就会有多个单例类的实例。
对第一个问题修复的办法是:
private static Class getClass(String classname)
throws ClassNotFoundException {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
if(classLoader == null)
classLoader = Singleton.class.getClassLoader();
return (classLoader.loadClass(classname));
}
}
对第二个问题修复的办法是:
public class Singleton implements java.io.Serializable {
public static Singleton INSTANCE = new Singleton();
protected Singleton() {
}
private Object readResolve() {
return INSTANCE;
}
}